{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tracing\n",
    "\n",
    "Jun Wu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Example:\n",
    "\n",
    "```\n",
    "[-----span 1------] <- {\"name\": \"span 1\", \"module\": \"a.py\", \"line\": 30, ...}\n",
    "  [--span 2--]      <- {\"name\": \"span 2\", \"module\": \"b.rs\", \"line\": 40, ...}\n",
    "  ^          ^\n",
    "  |          |\n",
    "  |          {\"action\": \"exit-span\", .... }\n",
    "  |\n",
    "  {\"action\": \"enter-span\", \"span\": \"span 2\", \"timestamp\": 10, \"tid\": 2, ...}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Schema:\n",
    "\n",
    "```rust\n",
    "struct TracingData { spans: Vec<Span>, events: Vec<Event> }\n",
    "struct Span        { meta: Map<String, String> }\n",
    "struct Event       { action: Action, span_id: SpanId, time: Time, pid: u64, tid: u64 }\n",
    "enum   Action      { EnterSpan, ExitSpan } \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Implementation:\n",
    "\n",
    "```rust\n",
    "struct TracingData { ..., strings: Vec<String> }\n",
    "struct Span        { meta: Map<StringId, StringId> }\n",
    "struct Event       { ... }\n",
    "enum   Action      { ... }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing Integration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Rust, Python, Logging, Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "  +-------------+                                     +------------+\n",
    "  |             |  tokio/tracing              Binary  |            |\n",
    "  |  Rust Code  +-----------------+         +--------->  Blackbox  |\n",
    "  |             |                 |         |         |            |\n",
    "  +-------------+                 |         |         +------------+\n",
    "                              +---v---------v--+\n",
    "                              |                |\n",
    "                              |  Tracing Data  |\n",
    "                              |                |\n",
    "                              +---^---------+--+\n",
    "+---------------+                 |         |         +--------------+\n",
    "|               |    bindings     |         |  JSON   |              |\n",
    "|  Python Code  +-----------------+         +---------> Chrome Trace |\n",
    "|               |                                     |              |\n",
    "+---------------+                                     +--------------+\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing in Rust"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Proc-macro:\n",
    "\n",
    "```rust\n",
    "use tracing::instrument;\n",
    "\n",
    "#[instrument]\n",
    "fn plus0(a: u8, b: u8) -> u8 {\n",
    "    a + b\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```rust\n",
    "#[instrument(level = \"debug\")]\n",
    "fn plus1(a: u8, b: u8) -> u8 {\n",
    "    a + b\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Manual:\n",
    "\n",
    "\n",
    "```rust\n",
    "use tracing::info_span;\n",
    "\n",
    "fn plus2(a: u8, b: u8) -> u8 {\n",
    "   info_span!(\"plus2\", a=a, b=b).in_scope(|| a + b)\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```rust\n",
    "fn plus3(a: u8, b: u8) -> u8 {\n",
    "   let span = info_span!(\"plus3\", a=a, b=b, result=0);\n",
    "   let _guard = span.enter();\n",
    "   let res = a + b;\n",
    "   span.record(\"result\", &res);\n",
    "   res\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing Overhead in Rust"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "By reading `tokio/tracing` source code:\n",
    "- If a span is disabled, the overhead is a lock-free integer \"eq\" check (in one word: cheap).\n",
    "- If a span is enabled, the overhead probably involves some locking, memory lookups / cache misses, etc (in one word: expensive)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Good practise: Use `info` for summary. Use `debug` for loop body.\n",
    "\n",
    "```rust\n",
    "fn download_files(urls: &[URL]) {\n",
    "    info_span!(\"downloading files\", count=urls.len()).in_scope(|| {\n",
    "        urls.iter().for_each(download_single_file)\n",
    "    })\n",
    "}\n",
    "\n",
    "fn download_single_file(url: &URL) {\n",
    "    debug_span!(\"downloading file\", url=url).in_scope(|| { ... })\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Default trace level is `info`. To change trace level:\n",
    "\n",
    "```bash\n",
    "EDENSCM_TRACE_LEVEL=debug ./hg ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Decorator:\n",
    "\n",
    "```python\n",
    "from bindings import tracing\n",
    "\n",
    "@tracing.wrapfunc\n",
    "def plus1(a, b):\n",
    "    return a + b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Decorator, with extra metadata:\n",
    "\n",
    "```python\n",
    "from bindings import tracing\n",
    "\n",
    "@tracing.wrapfunc\n",
    "@tracing.meta(lambda a, b: [(\"a\", str(a)), (\"b\", str(b))])\n",
    "def plus1(a, b):\n",
    "    return a + b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Manual:\n",
    "\n",
    "```python\n",
    "from bindings import tracing\n",
    "\n",
    "tracer = tracing.singleton\n",
    "\n",
    "def plus2(a, b):\n",
    "    spanid = tracer.span([(\"name\", \"plus2\"), (\"a\", str(a)), (\"b\", str(b))])\n",
    "    tracer.enter(spanid)\n",
    "    result = a + b\n",
    "    tracer.edit(spanid, [(\"result\", str(result))])\n",
    "    tracer.exit(spanid)\n",
    "    return result\n",
    "```\n",
    "\n",
    "Note: No line number or module name recorded automatically."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing Overhead in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "export CHGDISABLE=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0.0x      0ns  # nop\n",
      "   3.4x    266ns  # wrap\n",
      "  12.9x    998ns  # wrap_meta\n",
      "  24.5x   1895ns  # bindings\n"
     ]
    }
   ],
   "source": [
    "~/hg/hg debugpython << 'EOS'\n",
    "from timeit import timeit\n",
    "from bindings import tracing\n",
    "def nop(): pass\n",
    "@tracing.wrapfunc\n",
    "def wrap(): pass\n",
    "@tracing.wrapfunc\n",
    "@tracing.meta(lambda: [(\"color\", \"blue\")])\n",
    "def wrap_meta(): pass\n",
    "def bindings(tracer=tracing.singleton):\n",
    "    id = tracer.span([(\"name\", \"bindings\")]); tracer.enter(id); tracer.exit(id)\n",
    "base = timeit(nop, number=10000)\n",
    "for f in [nop, wrap, wrap_meta, bindings]:\n",
    "    duration = timeit(f, number=10000)\n",
    "    print(\"{:>6.1f}x {:>6.0f}ns  # {}\".format(duration / base - 1, (duration - base) * 1e5, f.__name__))\n",
    "EOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Trace-Them-All as a Profiler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It could be affordable:\n",
    "\n",
    "- `wrapfunc` has 300ns overhead per Python function call.\n",
    "- A command like `hg sl` can take 1 second. It has 200k calls.\n",
    "- If _all_ functions are wrapped, the overhead of `hg sl` is 60ms, or 6%.\n",
    "- As a comparison, `import sapling.eden_dirstate` takes 50ms.\n",
    "\n",
    "If some functions are not cheap to trace, we can blacklist them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "To trace functions in modules automatically (simplified):\n",
    "\n",
    "```python\n",
    "def tracemodule(mod):\n",
    "    moddict = mod.__dict__\n",
    "    for name, item in moddict.items():\n",
    "        if callable(item):\n",
    "            moddict[name] = tracing.wrapfunc(item)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "To get a chance to trace modules at import time:\n",
    "\n",
    "```python\n",
    "# PEP 302: Import Hooks. Easier to use than `__import__`.\n",
    "class ImportHook(object):\n",
    "    def find_module(self, fullname):\n",
    "        __import__(fullname)  # can also measure import overhead here\n",
    "        tracemodule(sys.modules[fullname])\n",
    "        ...\n",
    "\n",
    "sys.meta_path.insert(0, ImportHook())\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`sapling.traceimport` added to handle automatic tracing. It is enabled right before `sapling.hgdemandimport`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python tracing can be turned on via `EDENSCM_TRACE_PY`:\n",
    "\n",
    "```bash\n",
    "EDENSCM_TRACE_PY='*' ./hg ...           # (attempt to) trace everything\n",
    "EDENSCM_TRACE_PY='import' ...           # trace import overhead\n",
    "EDENSCM_TRACE_PY='import sapling.*' ... # trace imports, and sapling modules\n",
    "```\n",
    "\n",
    "Wrapping happens at `import` time. The importer is changed at `sapling.run`, before enabling `demandimport`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python Profiler / Tracing Feature Matrix\n",
    "\n",
    "|                      | statprof | traceprof | perftrace | tracing |\n",
    "|----------------------|----------|-----------|-----------|---------|\n",
    "| Profiler Overhead    | Low      | 14%       | -         | 6%      |\n",
    "| High Precision       | No       | Yes       | Yes       | Yes     |\n",
    "| Auto Instructment    | Yes      | Yes       | No        | Yes     |\n",
    "| Include Line Numbers | Yes      | Yes       | No        | Yes     |\n",
    "| Call Count           | **No**   | Yes       | Yes       | Yes     |\n",
    "| Trace Rust Code      | No       | No        | No        | **Yes** |\n",
    "| Trace Imports        | No       | No        | No        | Yes     |\n",
    "| Metadata Annotations | No       | No        | Yes       | Yes     |\n",
    "| Clean Traceback      | Yes      | Yes       | No        | Yes     |\n",
    "| Trace Multi-threads  | No       | No        | No        | Yes     |\n",
    "| Deserialization      | Yes      | No        | No        | Yes     |\n",
    "| ASCII Visualizer     | Yes      | Yes       | Yes       | Yes     |\n",
    "| Chrome Visualizer    | Yes      | No        | No        | Yes     |\n",
    "| Merge Traces         | No       | No        | No        | Yes     |\n",
    "| \"No\"s                | 7        | 7         | 9         | 0       |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Output Formats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- ASCII\n",
    "- Trace Event: `serde::Serialize` (which can be converted to JSON, CBOR, `PyObject`, etc.)\n",
    "- Tree Spans: `serde::Serialize` (which can be converted to `PyObject`, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "cat > ~/print << EOF\n",
    "#!$HOME/hg/hg debugpython\n",
    "import sys\n",
    "from bindings import tracing\n",
    "\n",
    "t = tracing.tracingdata()\n",
    "with t:\n",
    "    exec(sys.stdin.read())\n",
    "\n",
    "if sys.argv[1] == 'ascii':\n",
    "    min_micros = int(sys.argv[2])\n",
    "    print(t.ascii(min_micros).strip())\n",
    "elif sys.argv[1] == 'traceevent':\n",
    "    import json\n",
    "    print(json.dumps(t.traceevent(), sort_keys=True, indent=4, separators=(',', ': ')))\n",
    "else:\n",
    "    import pprint\n",
    "    pprint.pprint(t.treespans())\n",
    "EOF\n",
    "\n",
    "chmod +x ~/print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The ASCII Format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Accurate recursive call graph (like traceprof)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 2366865 Thread 2366865:\n",
      "Start Dur.ms | Name               Source\n",
      "    0     +0 | __main__.fib       __main__ line 2\n",
      "    0     +0  \\ __main__.fib      __main__ line 2\n",
      "    0     +0   \\ __main__.fib     __main__ line 2\n",
      "    0     +0    \\ __main__.fib    __main__ line 2\n",
      "    0     +0    \\ __main__.fib    __main__ line 2\n",
      "    0     +0   \\ __main__.fib     __main__ line 2\n",
      "    0     +0  \\ __main__.fib      __main__ line 2\n",
      "    0     +0   | __main__.fib     __main__ line 2\n",
      "    0     +0   | __main__.fib     __main__ line 2\n"
     ]
    }
   ],
   "source": [
    "~/print ascii 0 << 'EOS'\n",
    "\n",
    "@tracing.wrapfunc\n",
    "def fib(x):\n",
    "    return x if x <= 2 else fib(x - 1) + fib(x - 2)\n",
    "\n",
    "fib(5)\n",
    "EOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Annotated metadata (like perftrace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 2366892 Thread 2366892:\n",
      "Start Dur.ms | Name               Source\n",
      "    0     +0 | __main__.fib       __main__ line 2\n",
      "             | - x = 4            :\n",
      "    0     +0  \\ __main__.fib      __main__ line 2\n",
      "               | - x = 3          :\n",
      "    0     +0   \\ __main__.fib     __main__ line 2\n",
      "                | - x = 2         :\n",
      "    0     +0   \\ __main__.fib     __main__ line 2\n",
      "                | - x = 1         :\n",
      "    0     +0  \\ __main__.fib      __main__ line 2\n",
      "               | - x = 2          :\n"
     ]
    }
   ],
   "source": [
    "~/print ascii 0 << 'EOS'\n",
    "\n",
    "@tracing.wrapfunc\n",
    "@tracing.meta(lambda x: [(\"x\", str(x))])\n",
    "def fib(x):\n",
    "    return x if x <= 2 else fib(x - 1) + fib(x - 2)\n",
    "\n",
    "fib(4)\n",
    "EOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Call counts (like traceprof)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 2366912 Thread 2366912:\n",
      "Start Dur.ms | Name                  Source\n",
      "    0   +101 | time.sleep (10 times) time line None\n"
     ]
    }
   ],
   "source": [
    "~/print ascii 50000 << 'EOS'\n",
    "import time\n",
    "\n",
    "sleep = tracing.wrapfunc(time.sleep)\n",
    "\n",
    "for i in range(10):\n",
    "    sleep(0.01)\n",
    "EOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Tree Spans Format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Used internally by the ASCII render."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(2366997, 2366997): [{'children': [1], 'duration': 0, 'start': 0},\n",
      "                      {'children': [2],\n",
      "                       'duration': 3,\n",
      "                       'line': '2',\n",
      "                       'module_path': '__main__',\n",
      "                       'name': '__main__.fact',\n",
      "                       'start': 137},\n",
      "                      {'children': [],\n",
      "                       'duration': 1,\n",
      "                       'line': '2',\n",
      "                       'module_path': '__main__',\n",
      "                       'name': '__main__.fact',\n",
      "                       'start': 138}]}\n"
     ]
    }
   ],
   "source": [
    "~/print treespans 0 << 'EOS'\n",
    "\n",
    "@tracing.wrapfunc\n",
    "def fact(x):\n",
    "    return x if x <= 1 else x * fact(x - 1)\n",
    "\n",
    "fact(2)\n",
    "EOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Trace Event Format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Format specification: https://github.com/catapult-project/catapult/wiki/Trace-Event-Format.\n",
    "\n",
    "Supported By:\n",
    "- Chrome `about:tracing`\n",
    "- Chrome DevTools - Performance\n",
    "- https://www.speedscope.app (might render incorrectly: https://github.com/jlfwong/speedscope/issues/223)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"displayTimeUnit\": \"ms\",\n",
      "    \"otherData\": {},\n",
      "    \"traceEvents\": [\n",
      "        {\n",
      "            \"args\": {\n",
      "                \"line\": \"None\",\n",
      "                \"module_path\": \"__builtin__\"\n",
      "            },\n",
      "            \"cat\": \"default\",\n",
      "            \"name\": \"__builtin__.id\",\n",
      "            \"ph\": \"B\",\n",
      "            \"pid\": 2366999,\n",
      "            \"tid\": 2366999,\n",
      "            \"ts\": 73\n",
      "        },\n",
      "        {\n",
      "            \"args\": {\n",
      "                \"line\": \"None\",\n",
      "                \"module_path\": \"__builtin__\"\n",
      "            },\n",
      "            \"cat\": \"default\",\n",
      "            \"name\": \"__builtin__.id\",\n",
      "            \"ph\": \"E\",\n",
      "            \"pid\": 2366999,\n",
      "            \"tid\": 2366999,\n",
      "            \"ts\": 74\n",
      "        }\n",
      "    ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "echo 'tracing.wrapfunc(id)(1)' | ~/print traceevent"
   ]
  },
  {
   "attachments": {
    "catapult1.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAABegAAAMxCAIAAAAfRcQXAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwwAADsMBx2+oZAAA7lhJREFUeNrsvf+fFcWd739+3X9gP/fuvZu7N/dms8kjhnzZJJo1iTEG5JuSMRiNmzUxRmKMEVAQERVmJ0hUEAXkqwrCjIAgX+WrIOAwAwgM34RhAAVmcKKiuTG7JtkY5/Puru7q6uov58ucM3POmefr8UqnTnV1dXXPOS317HdVZf7byJdeWr8BY4wxxhhjjDHGGJeV/9vIlzLyvwu+Ojo6SJMmTZo0adKkSZMmTZo0adKkSZdD2gM38rmxsbG+ciStlTZ3tHeUVctVq9rb28unVdIM1R51r0iTJk2aNGnSpEmTLnV6QnVJXVcRK1T3akKfVF++dtRHvpPqeVjMCts7PHAj9S5ZsuTDypG0tt1X+bS8DFtlNgkhhBBCCKEekPQ0/lQtUv26Il5U0SvsyzcTVeJ3oNzqKfMfuKrQAzfnz59fvHjxf1aOpLXnfZVPy8uwVWaTEEIIIYQQ6gFVGbgp7kUVvcK+fDMR4Kbqf+CqwgDcPPfcc3+oHElrpc3nzp0rq5aXYaukGao9bNmyZcuWLVu2bNn2zLb6wI1cVxG7YdV3l7h2VLngprjfyRI9MTxwI6lFixZ9UDmS1kqbz549W1YtL8NWSTNUe9iyZcuWLVu2bNmy7ZltlYEbdV1F7IZV313i2stTH7Qf3Nr2To5lz7dsdRRX/p02O9+u+d22rVvtw9/x8g6e/31Zg5vifidL9MTwwI2kpIf/+3htfSBj64GXf19yvSynfWBrwk7FI5SSW+6o7elrgnbfv7WkTc6tVc79LOINdC5w2IK2HJqEEEIIIYRQDyi2x3Jh3agvhTRq7fmKYQ1F74bFVbh/zpe+NGd/NOfC2nus/ILkVObf+nUX0kqeXztKnVAnyvVmFqhdEzOZiTvNRLVSmwQQE6d32pKKKihj7LRr/v35gx6dcejPwfYPvDIt5z/wDg8OLk9w0yM/8GKAmzfffPPZZ5/9Xby2TMhkJmwNPp9cMFQytvyuxNo6IeUs0to3fSW33G7qlvGZzPgSNjy3Vtn3s5tyrnHY/JM5NCmr9j1xdWbQ9H1vvrlydObqJ+T/nYQjyXzxbjd19fTmuCPT9u6bPihz94tuGbfy0FFWDkIIIYQQqnwlgpt71l4wOYL5sYzBTcpFuWjjS+ELcThLCpZKqXD/7C99afb+NJJTqFxqpqtyWzh7f3Zw08M3E3BTPDnRLi3n30mKuHFQixkh4wfHhKNjNNBpM9hLTM0GmtGxOZJQBMfLe7d8wU1xv5M5VxiQ1PQfm6owBG7ej9fm+zOZ+7ek55RAW5yTbE7YqXjEG2+8kdry9zffl8ncZ9RxbN7Q5Dq7r9xaVeS71zp/aObaea3JTVLtyWW794kBmUHT9wY5+6YPGjC92Unve+LqAU/sTTo2de9eB9ysfENjmtzbw5YtW7Zs2bJly7YStzmBG58O7J/9pVH3jNJhIA68iESF6Ey/h6PgSHyOf2A0x+gr6ZYo8pIcAaR6TXJdyeBmlLQ/OFZy7hk1KhXcJN6lMKnxOY4RcRO0VmXIAd6JjNsbjdAJitk57l9hrRcMpcroezRnv0lw7FvnnmW2n+ljIP2XigVDadfeK+Cmjw6VckiKoiqKwnzgZUapjcdfsg2V0mhGR9w4CR/WBGE45QluivudzPLEMH7d3nPJfYakhB+qFnrgRlLPPPPMexffi/MmBzRsSs45MneINxJpyNwjoTLe+KSUkk7O/fePC4ptGucfNc49SXyT3pPWSpvPOEpp+Xsn5g1JruTE3GuDMVSb/Jwh8054BTYFDdCtyozblHQu1Sppj9Om/O6n2VpX1849cTF608yz68YPuX/ckFD5mCad0fcqPr1CxcsMGD3KATd7JGNUZsD0lx4f5J12xMgBXmrUimg9e6YHe50Dn9jr5u993OU1Z87skcToFWfeWHl3ZtDje6zzDnp8r6R3P+5XMeDx3V79UpWXNX2PW96tZ9RosyXha1nh7Rs1+m63nqBhoXqS7wNp0qRJkyZNmjTpYqRzATf6o9PV9/ODwBCXUChm4GQqCmCwHi/HoQlOnyco42Q5ZaI5RgdJh5wYjENKJbMGuapkcOOAD82GLjjptXNSwY26V3EVmuRG0xbdyGCvvmmS8HNGjbpH05wIt7GDm5w6nTYrEuReePAHig6VCv4coVvnlff/CsaJZG/MHQhd+5mFwzLDFi6aqP6tPmzROV1s54P6n/DDFp7xUct1Eyde5+fsmmgXcI/TuRN36cxzC6/TtfmwJjbiJqgzaEzQkusWBu1zWh45e3yTyhLcOOE2fm4wyikO3MheF+tkn+PGj9nxYY0ZZVPu4Cb591hwhclPjOA3GUK0KaMXVQs9cCOpp59++t14bXAGGG0MPr/ukITxG6J7N47381+fc01myNzXneThOUMyQ+YcDpUManD2+iUjNRhnsSWtdf6jcPpMast1Pa6umfP6u+GrGLfh3XBrnUy/2IZxGVXAyDSuK7lVp0+fzut+xl+70TavcHAnzSY5tVmXZjVJtUfdq5h0owNNRq847ZCRgZnMoMebT592+MvjeyRn2kCHuUh5B4KMfCGpHnevQ1JeGOnwETdfH6vAzekzK0ZnBjqVBsc6OdP2uOeVkk6+5Lj1NOtG7VYprx63vHtgZsC0xlAbHNATHDvg8UaznXKAXZ40adKkSZMmTZp0idK5zXHjA5PZoXgN3YGJiTeJoRveXgPTGKeL5mh+4SGG7NPHqF6TXFcKuNlvA4v96eBG3avYCoM7EKpT8Srjun2k4l/mhbWz1+5fN8orZhGouFFp3olCb/tDYTghcGPW4DXDRz/mgdmGv4WuXeEPBUTctEdbHEbjURKHmzy4U2MRH8fsnBgCOqqwA2g84KKQkFvg3KJhXg1mgRhwE65T7zVa4tMcBw8FTY093KQ8ZQhuQpPOaF4TBTcfnG/xcrKAm5ihUpUUcZPyeyyYBEmdOVeY5SnkVHjaBzdS74IFC96J14b77LmJB88+5O/ceF/mmtnHvA/HZl+TuW/jO+8cmj3YLKNLZu7bYNQZLbnh3kzm3g1x5W1Ja6XNp06dSm25IedEru7dEHuBg+cc84up9si16ITb1JjrLaxV/rVbuVmv3ckMmuQ1WD7MGZzeJNWexO0LozIDpzWF0y+MzPR/vOn06WYXvjglHRoycnlSPXrv8pGZAY83u/n62CZJjHrh1GkX0zSbx3o5wVl0nUY9Tjoz8gVVj9sqKbPcATGvmm0wc6y9clV2/WzZsmXLli1btmxLt81pqFTM22aTBWgkET9lb2iW4/AYK13YykkgR8bIoOR+nVxXGrgxkYdzjVnATcpdMomSeVt8cBOZ3VmdUbaznVbIIReM8J/cwE1ww5LATehv52Wavc3wiK3k+Y9D127CGpPR/CkcLBOAGz24yY2ssQo7tQWjnwzOEorHSQY3xlkXDTP2msE7US7jtNAtENekSo+4CebB2RpdMcqsOYR1fIiT9xw36jtcGnCzf3ahv8fw7yXpIZbHEyOO2qRPFq5a6IEbSc2fP/+38VrvhJ68pNJHnhqayYxdr/cd8XmIAXWO/PYl54j14VqckkOfOmLV2fLU4Mzgp1qCyp3DlZxddiVa0tpTvpJbHpFTp38tL+nhT4MHG+ddP9ZNS0mvtevH2dyqm60y72dwe0LXbtxAaY+noYP9exWuQQoHNzatSbFqery/gjWOfHCz3AU3mrl4xUYuT6vE3esfeMo41k/4lQcKcpb746JGLfeP9evRlQeNccv3n/aqUdWr0/oHOebeUFUIIYQQQqgHVCi4yT3iJmVKiMT5XKIxOFnphu41ZQM33pAlAzZl6SimVjhq7X6TpxjgJqaFstcJ+fEozOy1cWOU0ue48XfpdM4RN1Fwkx5EELp2Iy4mFBpjDEQaFg9uQqOizJCckOx8p7ZkcBOMqBp23bDY8VOK4LhYJyQzEid06qqY4yYGzWSNuHErzGtVqVyASPcibhL5SJbfY+QrnT6sKZ8Ksw+SigE3bW1t8+bN64zXOpcihD4Oeuqw92n9uMzQWYetIw7OGpQZNOtgONOlDeusOsMl143NZMauiytvS1rb5iu15VYz9LUcnjVUX4WZ9q5o3VODzL3G5acp51bFVBh/7eb9CdKhBh9+alDMnyCuSfFaPiozcOrucHrZXZn+0+T/d08dmBm13Nmze1r/zF3LkurQe/0DneSojDrWr8Q8UfTU8Q1oU3W6lQeNcSvvP3WXeaSZE6TNehBCCCGEUM+oYHATO8dNMJbKJwvhHKs35U0eEc0xIYU/R4xBHJLnuEm5qBDacKCJ/pAGbtIq1HMqB42JmePGXCXKnd3Gn4DGScfc5MRVpdwbqG5UAXPcWODGQGOJc9wE154QcWOG3oSHSsVNJ6wrCUfcmDE7PlhJHSplT3aTGoaTPhIqfF1lCW6iq0p1D9zoBcLDYTn+UlWhauO+9hfkO/ylFCUQ1cTfToJGzd5/Ie/fY2x4XZaRTblWmIVBhyoMwM3cuXPfitc6ZxDPOitj0KwDkb0HZg3y0odcsnAoXCAoeegpv+ABF0YciKl53ZiMdVpT0lpp88mTJ1NbblcSnNdtYWbMOv+kurX+Z+uoobMO6Qr9dKGtitxPO9toW3BL1bV4N8e+kNQmqfYkb5c6k8Msk/Tux67OONzk5EmHdzj8xMkZtdwp6aKZpUn16L1L7/JqaHNjaNxjHeDi1C85Vz+22zzWy1k20uUsXo5bz+6p/eXopZKzy02Z9Xht7v/YzlAbXL6jj3X26pxsd4AtW7Zs2bJly5ZtMbcFg5s/xa8qlcsaUtG1deNW282tVLTXJNeVBdx46z3Ziz3FVphyl/RoI6M1satKGfUbHcm0F/jGSKugjNv+ObPtQWZzclxVKm4e5fShUsG1q8gaI8pGwQ4H1hgT38SAm1Cojp5cxmQ0elSUNdgqHdwE9ahMB9ZoRhPwGmOOmxA2ijYJ5RMp03tDpdJ/jwVE3KQ9MQq6Y1KbB24kNWfOnI54rXFiQdaaOS0znYWOxq5Rn16bOdAPChs4s8U8ys4MSg6c+ZrO8dNe1V6RgfeMHahPEZG0Vtrc2tqa2vJQhe4STEH7Otb6DbxnzZp7nG1wweGPXo6nxCbl3KrgzlitCppqtFOfeuza0B8iyL9nbOi6Ik1S7UnbLhupqho59bH+Vz/W2Nq69K7Md6c2njzpgJuRy5wyDg351dKkGoy9S7267nrMP7bRTbhnufqx3SdPNk79buaupd553ZxWvwHShKV+nQ4DcuW2xKjHO0v/x3a0ntz52HflEK8l3qm/O/Uxd69TPqTk9rNly5YtW7Zs2bIt4raXF3sudj9TXVcWcGOGsWQDN2V0l0Jz3PTEzQyu3YUdEx8cZq8qpYdKXbdwp0YnVhRM3ApQ8YOVdMkHd8bE78QMlRq2cFdAYWLWtwoN5jLOHt8k1M0hTj1RTy6/x7zmuEl7YhQUcSO1eeBGUrNnz26vHElrW32VT8vLsFVmk8pOLrhpLEW1LgBCCCGEEEK9oioDN8W9qKJXWHHgxrv28Bw3CHDTi+CmnH/gIXBz4sQJ6eGfrxxJa0/4Kp+Wl2GrzCZ1X8//KhPVXUsLr6qwY+P06qNBfM13H33lBEIIIYQQ6i1VGbgp7kUVvcJKvZmAG8BNedRT5j9wVWEAbmbNmnW2ciStlTYfd1U+LZeWqCaVz/1UTdL3ijRp0qRJkyZNmjTpUqerD9wU8aKkHnWv+ia4Ca4dcAO4KY96ivt7VBUW/YnhgRuFP96sHCke8bqr8mm5tEQ1qXzup2qSvlekSZMmTZo0adKkSZc6XWXgRl1XEbth6l71TXDTZ68dlS24Ke53UlVY9CeGB24kNXPmzDcqR9Ja/V+I8mm5atWxY8fKp1XSDNUeJdKkSZMmTZo0adKkS52eUF0qejdM3asJfVL62kEYgJsyqae430n1xJA6SwJupN7Vq1fPqBxJa6XNx44eK6uWq1YdPXq0fFolzVDtUfeKNGnSpEmTJk2aNGnSBaSLCC+4nxMQKhsV/TupvufFrPDoMQ/cHEUIIYQQQgghhBBCZSYP3BxBCCGEEEIIIYQQQmWmANwcPnyYLVu2bNmyZcuWLVu2bNmyZcuWbflsPXDzH//5R4z7gqdNm9ZVPO3bt+8rX/mKJC5evDhixAjZNjY21tbWdiHUt/X222//7d/+rfppyC/iww8/VIn33ntvzJgxra4kYX2UYtw6VPX6m7/5G/1Vl/9kZDIZ2UoOP42+IPlzt7e3v/nmm6dOnTpx4sTRo0flnyWSeRH1PVXH351vL0I99pMB3GDATRHAjfzbWtWsu6mqwJIlS+Sj/ERrXUlCcmTviBEjJD1gwAApzz9kURWDGy310+jo6FA/EJEk2trazI/65yD9WOms9uvXT34pc+fOVb8gyVc/IsmXXxw3GVU6uFHEX/7bIV94/d8OfhqAG0T/jatAiB8+4AYDbnoB3ChSI//gVu9ODx06VNxmIFT+4EZ+CHn1TuUnozLlR6T6t7owtxdVB7hRPwr5hvPTANzQmaH/xlUgxA8fcINxb4IbFQOv/uWt9/J2FPUdcKPBpfkDydo7ld+OJORnJb8RvVcyM65UbQhVLriR7/OAAQPU91kS1m+Bnwbgpgp0/vz5HTt2rE2Q7JIC9N8q/fYmXQV/fYQANxhX0hw3SeDG+ic4QlUMblQPU0OcXCbySOqdqr2akyJU0RE31n8m+GkAbqpMr7zyyrFjx95LkOySAvTfKv32Jl0Ff32EADcYlyO4Uf/4jk5bEwtuDh061K9fP+a4QX0B3EhPUn3b9Rdezcaqw82sjym907a2NhWhQKgaqj5wE/0t8NMA3NjaND4TaMjcI6XuXxyfe20mc+3c44Uev2bNmmjmgQMHbrvtNtkmFaD/Vlm3N+kqsp69j//1ET98wA3GvQZuEEKxETcIoRRwgwA3ufw7/vi8ISas2TiuB9hNd8HNihUrLoQlV33DDTdcddVV11xzzeHDh6UA/beLFX57k64i2jxLffyvj/jhA24wBtwgBLhBCHCDqgjcHJnrYJt5x5Pxyvjx12qUs1FH5viHmAjG3Ttuow7hGT/OL64y42sOV+6XdPnR+I0RrqTU0NDwRli33377la6mT58uH6VA+iWHNX5jt7pL0vJwC2NOkXST8z9XDsArh/6b/AkS8VzhtzcUuuXf3E3On3v8JnVb1K32cwq6imjzLKX99cONTP+jyJewSH81hAA3GANuekkPPfRQOf/7leZVcfPKHNzwx63i5pV/C8sc3PD1K2nzCgM3sVgkhFeCvREusykLuFFp9xRWL92s2T3KrUHDGrOqFHBz7NixBx54QLaTJ09WWGH06NHZu+4OPihuSFEE3Ji3txuBRQnnimVhefTf3PucFlfVrdurTxFtYTmAG+ebqS/caUYKmgHcIMANxoCbigc38mgo8xePNK9am1fm4IY/bhU3r/xbWObghq9fSZtXBHBjRyKEBzQFsMbkNakRN5sixCduqFTQBn1U6PD4rvuxY8d+/OMfX3nllddff73CCjfffLNkFgpuQigh6LHre+K11i0WiiRSECqeg4TAjVSl09IG/+6Nn+eF5wSMwD5pHLhJDRhJ+rsriJZ1MqNu3d4YcKPurW75+I3m3U6+2BKAmwipCbMksyX6XqnyPu0yD9cQbXxA7oJgKy+My/kuXevkDfnNI0OC2C45tptxXggBbjAG3PDvb5oHuOGPS/MAN3z9+gC4iUEkweCpBLxSOnDjlpRTG6E3aSEhEyZMuNLX4MGDd+7cmVPMRULEjdMMr5F+BE1Q0m2wxjSq5UHsRo4RN0ExyQ/usLpSfa6YkyaCG38sUg79t5hBTFkibgq8vYngJi7iJvViiw9ukoOtjAY7d1jdUs3vgr+j++vQeyNBYd4X2Nur48hM6qdx1Ti4DSo+uFlckAA3uC+Cm4ceeiiDEEIIIdTjKs4cNwngpicibrxerjv3TWq3VnfdNVxYuXJlroNlohPQBG12sYIfGhMXL2OGbGgQk+tQKbk6f3xZQCv0zVeYIDFIJxncRClM+O+e0yFFu735gJv0iy0NuMka5xLgFR/cxPyZwn90k/T59fuQyLwVPrDT3wSEigxuCngrEAI3XQih/PWnP/2po6OD+4CQpY8++ujs2bPcB4Sikh7Lxx9/zH2oAv0+f3VvVakwZIkFNwlcJoiOMea18dLGkJO4OW5UZjDHjRkYostnnZx4woQJasbcfMBNLLPwut+hOAt7DmNzRFXe4MaLs/DGScWPz4o7ae9E3BR4e/MFN8kX25MRNxbOi4Ibm/SFqvK/AJr9xX2djCFyjJNC5QpuLuQj6ala6QK2Sma6YMl/Aq10AVslM12wzp8/b6UL2CqZ6YJ17tw5K13AVslMFyzpzlnpArZKZrpgyb+frHReW/lvz5u+VE43ZVao0gVslcx0wTpz5oyVLmCrZKYL1unTp610AVslM12w5B/fVrqArZKZLlhtbW1WuoCtkpkuQHJ7ZXvy5Emdo9IFbJXMdMFqbW210gVslcx0wZKem5UuYKtkpgvW8ePHrXQBWyUzXbBef/11K13AVslMF6xjx45Z6QK28uzRNXRT0u230gVslcx0wTpy5IiVLmCrZKYL1uHDh610AVslM63Vk+Amplfvdbmji3YH1CCABbrH68z0ESY70dlbQhE3elUpsxOrThHkxIKbdevWNTc3J/3rQnZJgfzBjepjb9TLLRmDp2Knwskf3Lg99rl+2EU4lMNLx520p+e46dbtzRfcJF9s0lV0o3nR2YgVQ7H/EFFwE6FjeUTcGGd0g63mMU4KlT24AcoAZYAy1jYdykjvFCgDlOlrUMYEMUlQxgQ3QBmgTB+BMkrpUEaBG6BMmUOZXNTT4Kboyja7cBYwka1bK1cnnfOGBMkuKVAAuDEDhayS/kwl3QQ3KkApOlVQ7Bw35vQoEXBTylWlunV7C5zjJuZik66iW82LrCqlpy4yp6NOnOPGmsUmtzluTFQUF4CGUGVG3FzosKJv1t5rhfWNWdujoKfdBD0HZ2pOPWRGi8I3r80cGDRu7OoQ1lk9VrLW+Dm65D2rw6BHig2csc//tG/GQP8UB/28g/okd6+2Qc/5XgU95yKg51yvgp6zEdBztldBz5sR0PPm2XwjbnIHPTnQnQjoeaNXQc+ZCOg506ug53QE9JzuVdBzKgJ6TvUq6GmLgJ623gE9Cty0nYyAnpO9Gn3TGgE9rb0Kek5EQM+JXgU9xyOg53ivgp7XI6Dn9V4FPccioOdY3qBHfhpWxE3h0TdHI6DnaK+CniMR0HOkV0HP4QjoOVxM0NM3wY0PFLKPIpF/2Kc8q2WXFMhjjpvwkuehiIwgFim6jrXmNda66WngJjyTS2iNquB22ScNg5sc1hfP4e+u59kp9u1NATdBOFXcqlKRi026iu42z4wv043cFKwUZo2Vs1aVMq5Ljyucm2VVqfh1rBAqZ3DTERkS1ZE1+mbt2Ezm3nU6p2XmkMzYtaWAMu06Jym+5uDMgQNntrjplhlDMl5aGuhDHCv6ZvU9LstZo+mMSh90jz1oUBuRC27OB8XOnz/vHO5imvOrx0iBJ/fK7oNPDnaOBcpUAZTJJfomr4gboAxQpjqgjE9i0qBMjhE3QBmgTDVBmVyib3KMuAHK9C6UcbT4l5nMdx7e4n/c8vB3MplfLq6iiBuUTDTCA2dKEnxRHX/3irmK0NQ22YBZlqFwCFVOxE1kOJUFbjrWjnGIyYX9MwdmBg5ykObYtZL/2sxBHt28d40GOvv9MJUhM1tU1tqxmaSczNg1cTlJw6mcEJghDn1pkYQfQRPaSj33jB2rwY0TRzN2tQ6fUdE0bnDN2DVGxI2T46V1sYPuKbwom9VjdCQOw6mY44Y5bhhOxRw3zHHDcCqGUzHHTSUOp9o25TuZ/g9vc9LbH+6f+c6UbVU1VArFB7lYo4EAN5V7FeaMxYmxS3ExZYTboEoAN2Eo02IMO5rZkmvEzRoHhaz1oMzYtYqoOJkDXRSz5h4NZSRz4MzXOlSms9cZqaRy3FPfs0aNUVJl/Ggaj6GE42tiom+ccBinBi+sxic91uin1QG4WTM2GPrkXsTqyFApF6Z48Th+xM0q2X1ghgNuPNTiRN+MXQWUYY4boAxQhjlugDJAGea4YY6bCp7jZpviNZrgAG4Q4Kb6rgKhqoi42a/CZAbN3J/HHDeDZrX40TQD5UA/7cbdmPnOCCY/rMaFPi1ujEwQaOOkA7jjK5ITO5xq7Vg/HseZ9WbgzINOtouPwtAnmONGR+ikgBs9oc0MF2kFw6n8mp2id2f0scxxwxw3zHHDcCrmuGGOG4ZTMZyKOW4qdTjV1infcf7Fd5UeM5V1jhv5FzbgBgFuEEIlBjeROW5aZg7KNtmwPVTqQgBovMFNF9bdGwx08slLCNO4ajEnEfbiYzqCCYPdeWo6IjkxETcGoAnv9YJlnBq84Jr8Im4cBOMPlTp//rzDegY7h3jRN2pq5rudoVIHgDLMcQOUAcowxw1QBijDHDfMcVOhc9wYQTfRcJskcLPYV17gZhpCCKE+oLKb48YEN2svJETcvNZhRdx44OaeNUnzFEf3qhxrjhuX/gRz31jgxpk4eU17hBC57CZ2jptIxE1olzHfjZYaNsWS4cxxwxw3DKdijhvmuGE4FcOpmOOmoodTuYOkfnlnZIKbWHCzOKzcwU0XQgihapf6r0CJ5rjJcUlvG9wYEw+bUTaROW6CGW3czHvW2DlDZh50YYqqxBvc5OOV+Dlu/EiZ8ILffvSNHUcTjrhJXFUqPMeNFXGTGbPan5DYjbJxZ7hZA5RhjhugDFCGOW6AMkAZ5rhhjptKnuPGWUnKXVhKJ5LBzeI45Qhu3kcIIVTtKjK4yS3kJmaOmywRN5FVpbwy6+61Jj+OriEVRMf44Tl2jjHHjTkPsSpwsL09GFrlUqF2G+t4c9y0myX9Vaji57hZoxsZZOpTDzQidZjjhjlumOOG4VTMccMcNwynYjgVc9xU4HAqZz3wq36zPbLC1JGiT05MfwYhhAA33Z3jRuXkHH1jb/XEwx2FKXbi4fhhUDltlcJQJh+dbwfKMMcNc9wAZZjjhjlugDJAGea4qeo5bqJT27g5dzxXilWl6M8ghBDgpgfmuOkNoNMRATodvQp02iNAhzlumOOGOW4YTsUcN8xxw3AqhlMxx02VDqcC3CCEEOo1cAOUAcoAZZjjBigDlGGOG6AMUIY5bpjjJl09BW5a512biej+zcfmDc1khs5vVYU23zd03jGVcPfSQ0II9bzc51Lm2nmtxkf9mCpCzdZjsAj1ygO25x6YEXDTVJdJUl1Taea4YTgVw6mY44Y5bhhOxXAq5rhhOBXDqZjjpg8Np+rpiJst92cSukCt853OURHATbRrdB8ICCGU9zPk/i0lATfFqcpQD5Pu1IibzvrhNfXtGujkAm6AMkAZoAxz3ABlgDLMcQOUAcowx02fnuOmfCJuEsCN7sa4+Rm/s2T2Q1yg40q/AM/69lkOcQqrMB8idxBChcFf9+kR0Bb3keI9iDbf70NhDzrP9x5iQ+dv9gMMIw+feHBjVms+/TbfbzwVjcPn3W8g6eAJqcC3Qa69o4pNuosDbqYhhPLXM888c+DAAe4DQpZmzZol/WfuA0JRtbW1PfHEE9yHKpBiMTtzUwnBTVLEjVve7X4E3aRc3kDrDk/RX24jhPoCuBl67VDvAZITuDEKqEeWAiLWIysh4satwYA1zlHBuYJnozGGKyFEMTgq9zAcA/3kdEhxwM1//OcfMe4Lln8hFfHp9MZbrWtOzsIYY4xxX3OZgxuz7+Gkcw668UN4CLdBCBU2oGmzF7KXY8TNsbh4mThwExPe4uY7uEejahPx6L0mDAqgdgTc5BOf+L55VG6kO+fJiQE3GANuMMYYY1z94CY6pXHuIMY5NqeRAgghFBsX40W4DC0uuImDI27N9222gg1NhWN/ksBN+MB8SXdu5YuzqlSJOskvv7xdX/5Pf3rruxff17smPPCgeUOtvfrwSy75fMuhwzrnfPuFq676rjpEaoieUQp/f/hwKWZmPv3Ms/pEUqe5SzdDqrWOwoAbwA3GGGOMKz3iBiGEehTceI+gTKbk4MarZOi1oRgcu2Qu4MaTN1y0FGNFyxfcKGqjQMm7F9//6U9v1XRGfXz6mWdTDleMxgQ3KkcdZaatQywEY9Ifs0mK2ujCkgm7AdwAbjDGGGPLU56/+1eTf/TDXw1ZsveRvA786X3XPbXxQcBNRc1xgxBCRQA3enCTwXGMiJjigRt7KavkOW5SwY1xUqNAicFN7HLgdU09P1RqwgMPmkExLYcOX3LJ5xU0UYTFCn6JHi4NN8HN0888a7IVC7Xo6B4zUxEisxm6VWZ7YhuMATeAG4wxxnj8UyOmrx4PuClbcGN2kLq5qhRCCBUH3ITmHjYmqbnv/uLMceMf+H7MKnhJq0rZ4EYPjwrmwcltfahqi7iJjaBRoCR2QJMVrSOFly5bboIbC6yYFSpq8/Qzz1pwJwXcRENs5NjYEVsYcAO4wRhj3Df9wuHpv6i9sX7foz/81ZABN1wu/9z64uWfWbL3EclXH2Uru+SjPmT0oz9Wxb5361WAm6KBG4QQQpWs0oIbBT5MtJUeJpM+ckpTGHPSmegEN3oYlHlIdHRV7GgpC9ykDJWKBTeMlgLcAG4wxhhj7ac2Pjj+qREK00x5/m7J+eGvhkhi9KM/FquBVLJLgxsp/71br5KPS/Y+8o3BXwbcAG4QQgi9n+tQKT1gKv+IG3OC4YJHEllz3Eg9FpEx2Y2OfCkKuNGjoqyBV7FDpQA3gBvADcYYY2yGz0x5/u4XDk/XQ6VUjh4GJZlmxI3sko8MlQLcIIQQ6rmIGzPoxlrgKd/5blIONxmKpL/znat0gEz3wY2JY9SJ1CGqQnNyYtaWAtwAbjDGGGPTd/z7D9XAKAvcZI24ETNUCnCDEEKoh8CNhhoFh9ukUxsTwVh0pvvgJhpWYxYwB4JJIxkqBbgB3GCMMcaavzyz89d3/PsP1Uw3FrjJOsfN//6n/3H5IIZKAW4QQgglgpvOhppgfFRzt8HNuxffHzlyVGHhNlmpjYlg9JgmS4rOpExOnAJudPxOFAZFm8rkxIAbwA3GGGOcyxAqHXGjx0b1KRcR3CxHCCFU7YqCm6ZaNZ1NZ/3wmvp22WYytU29s6pULLWJrvQUxSuxkCV9OfAcI270Udau2PgdDLgB3GCMMcZRL9n7yBcv/4yKrKnisJqeATe33Xbb4431bNmyZcu2irdxkxOrSYgVuDFzehbcPP3Ms0mxLebqToqYxI7DssCNWTKJs+Q7x405XzLjpAA3gBuMMcYY9wq4wRhjXK2OAzdOiE1NQ6cGN04AzvD6zh4GNwqsJA16ynGxquiwJrPa2KNi56kxVx83WY85xw2DpAA3gBuMMcYY9zy4oUuDMcZV75g5btrra7yhUi6SiKM2PTRUCmPADcYYY4wBN0TcYIwxETelXVUKY8AN4AZjjDHGvRRxM+tH384Mmltgh+GuWzOfnzirpH2S2olfyXz7jtq4Uxfc7LLzi3d8PjP8LpWIu1iMccX5Lm/4jfGQdH7pSu7v3co0f/txJf0Kv/KjF3OIuAHcYAy4wRhjjHG1RNx0C9z0gOPBzdzhmVsnVk8fT4Mb93pLzcIwxiV38IyaOCijnrHysPWYi/FY03tdLmMf4pZ0M4NDpGaT+xBxgzHgBmOMMcZVEXEzf8JT43/xZNhPTZ+swc1E7+1u+pthp+fgvu8ddKvXl/AiblzuMMh/vZyOgey30EnHzh0enMsGN0H/xyn27eGDvm2/iM71LDY9Cb/39toQ5LjXe8cglXnrRH1D1HmtvY9blZjnDZ1r4qDQrZaPoV4ZxrjSQ29sGmsG2WUiNCcOTBuVBFiHiBuMex/cvPPOO+fOnVPpzi0b3np+Ue5++fjBhrb92jvO/GHjkaMtOybl6P0bLu54rgtjjDHGveJSRNxMuO8L1rIen7lvuo64ydhdiPBLYNWXCO+NgBuvUxGUTw+fcQ9xThF7rN6rmmdVaI4ncrFIUFK/mg6uKPksIctFmfxllt0G/3rNmoPMYG/4Bsb2yuLPFRoQUT2jwDDu647hLMbTwHm8BI8m/wkWIGDvyWCGRgaHEHGDMeCGfzdjjDHGFQ9ugq7C9omDPmVgm08Nv2t7TB/A4whmKL7PFHTEvhm9b3AHMwQmCdzEnSv2WLOSaIXm62ijqXarGo3RB1lbGHuWEB5yzhIey2AQmTDBeTx8u+wKo+cKgxtGS2FcHfaC8kK/dy/CzkA5ip4HTy33qIDtuk8Sk/7Y4CYp4sZZAtxZWEqng4+AGwy4AdxgjDHGuOwiboyBTuEhUeE5bgxwY8rpQsRSiZiAkWzgJiQPqdjHhua1iVQYYiLGXj8/1KvxMmPOEjRGCkdn0gnl+IeHRyvEgBv7vMagLd1/i5m1B3CDcXXjG/upmBaUZz/inIdD3hE3Dqmp9ShNZ0ONQjZOIrwuOOAGA24ANxhjjHF+vv/2JTMmNIolUcDhj43dsuYp+z9hBddWbRE3ZtBNEG5j9QH8dBx8yRZxkyu4sQcBxR6bV8SNDW6SIm5SW5hzxE06uNEN89Jm7BIRNxj32YmK7YmrvIdtBBC7T5XsD5+sc9w01QXBNZ31wzM1DZ2RfMANBtwAbjDGGONCwU1hx25e8OEt19UCbtJXlZo8+QrJvHTyfDsKJm4Wm2BNk7gZcAoCN/ZaKsnHmuuwZJvjJgJuEua4SW2h8d7bYD0xc9xkATfBBMPusUGHLfY+x3El5rjBuDqibCyMazw0goeAFXETPEBUZnjqrjxWlTIBjaRr6tu7ADcYA24wxhjjwj1jQqP8i/P/fKLfDYPG6IibzQs+HHrlCDW+RD6ueeqi7L3y0hvko+TL3uceaZVDVAF1iNq1dvZ76kDZK2VklxyoSpoER2qQ/H/+XH8pfO/PnlHASMrf8cNpci7JVIeoc1VJxI3jX1/77ZvuiUbB+KtKxSx7ZCzV5A+2Gv6jAiNuQus9eb2apGP94VpO27KsKmWDm6RVpbK0MLKGVMKqUqlDpW4dHl6fSw/I+sqP5obbEKpZTXvBqlIYV9ViUvYjJXiuRlfQCz1sYxa5Cyo0iiXPcRMMlWqu08OjnKFStU3McYMBN4AbjDHGOD8rSiJbRWo0uFEMxSx25aU3SKakb7muVsos+PcWhVQkLTk64kaOlYTOl60GPTcMGqMpjAI3qkId6aPBjTqXWaY6Im4c7+x+hyRmasxeGHoQWS63HBf9LehFPeOkMMa5O2FVqaY6jwd54Tbu/MQ69AZwgwE3gBuMMcY4Z5s8xZrj5pbras2IG0Vn9OgnMyTHAjfmeCtdm1mDNbQqCm50SflY0eCm2NM0hINlciyc+1F5UpJyG09UBHDzYjS8CGOMs5jlwDEG3GCMMcY9EXGjQ2msWWlUgSWPtlkRNxqpRCNu1OEKCU0bty0XcKPKqKqqCdzERNxgjDGu/ogbwA3GgBuMMca42HPciK782g/MoVJ6Chtrjhs1EkpNaqOmoZEcNbXNVy4Z8MITHdYcNxa4sUCPQjzqXP/8uf5E3GCMMa7wiBs9TspUXROTE2MMuMEYY4xLGphjxstUt4m4wRhj3I2IGwVuTEZjIxvADQbcAG4wxhhjwA0RNxhjjHsr4qauqbkuk7wQOOAGA24ANxhjjDEuo4gbtmzZsmVbxdt4cCP/315fk8nUNQNuMAbcYIwxxrhcwU0XQgihalciuNHDpmrrADcYA24wxhhjDLhBCCFUbuBG1Fk/3JryBnCDATeAG4wxxhgDbhBCCPUOuMlVgBsMuAHcYIwxxhhwgxBCCHCDMeAGcIMxxhgDbsoc3Djrm8QE6nth/bWZmoZOr9jw+k43sN+dULOX5Mzo6bbWaw9CCHVfashSxljsqauzoUZlZWqbwo8gpeCxKc9J69h0cBPUnEl8nAJuMOCmmOCmmzrS/h+btpw9sWVyrl713qE5XUX3nl1tL556FmOMMcbp7tPgxujelAW4QQihIskhL4rO6OehPGo8NOw89PzHoDOdsHoAOvDFPcRJqJJxz9IouHEpjxSTamvq211gVNsEuMEYcAO4wRhjjPsCuHEXKNHvgV3AUe+915Xugb9X9xD898Z1tX5nw4hhUX0S/VrY6bQkRty4OQ1ebQHlaa6zXyk7NdQ4xfx6MkmHBKE0TUEtquUxETeRMsEL8JjrNXpWcW1ACPXJcBvvIeA8KOzAGc1onMdOBLIYdDvAOsngRk9OrMBNF8uBYwy4AdxgjDHGfQTcBDzF62O4nEJ1J1yK4fYQgj6J08Ew9saDm9yGShmrouj6jc5P+HW0ken1f/xOS3CIfgUd15uywU1cmeBCzK6R12znet29MW1ACPVNcpMWNRM8ZKRYTUN9CJGHHolmbE4SuNFlvKeTfiIBbjDuK+Bm59SLv7imdte092QracANxhjjonvm5od/Mv7GRftm3HjX95YenZvv4dPWTJIarEypR2qTOsvwvBUDbqIDiCx0EhCKMP6Ij2HJG9zovkpkaJVRrdEjMpoU6Th1xc5fE2l5SpnoLrMz5tcQbQNCqE+zm0wm7tGRCT24/OeqP7rKjLLJBdzoR5Af8ZcwVxfgBgNuqhzc7J3xIRE3GGOMSwpuCj5cju0OuOn581YMuIm+JTbQTAy4iQMZ3QE3OkeXDwYr6Z5JmKfoAkGgUEh+kwIlgJtoGaO2oPEhGV2v1PlBEUIMldIPzBDt9TLzjbjJVYAbDLipNnCzd8aH3//mCHkiyJaIG4wxxqXwon0zvvCNz8l/a4bdOtCMfJGt6vfqjwNuvEI+SmEpo48SjZx62+Sl4/UulU46sNfPWy0RN8ngJlvEjZ6qM8+IGz9tgiGTsMS8W/aaFBf/Yr7KToq4iSsThUpZlqCKHogQ6jMKwZoY+BI3DDOgOXnOcQO4wbivgpvJtywRS2LhmMbvf3ME4AZjjHHRfeNd35u8dLwkRk69TUWpyHbBq9PMgUuSGHDjFbqYeOaWhxUNmbn54WG3DpQCKvJFMi8f8jVJSI7kP762Vh+oT9S7563AOW7Ca51I1yId3Bidk9AcN8YMOPnNcaM6M2b3xpgAIgpuwl0da44bPelD+KKygRtdxrjemDlu3GLR7hZz3CBExI03i7lFe42BnKFHaGGrSgFuMO6j4OYX19QuHNPIHDcYY4xLZIU51FAja66ZkVNvswJYNDFRI5t0aMyAG68wAYpFXvSBKkCmd89bqatKWasmZQE3QXl3rk2vpD90yF2OSvdJ4leVCnVg3KWpzDFHesGmmvrm2FlpgqWgAgwUDGgyZ5RQjWzyzhuJD4opE7tcVHB/9Kv1uDYghPqigqeBfmgY4zcNHKOfJDEDP2MC9wA3GANu7Iib1ZNaf9x/DOAGY4xx6SJuZKsjX0wCYgWwqMgXTUOikS9SUhETqWfSc2OTAEpvnbcylwPvzZfVgA+EEIoKcIMx4Mae4+ayz/Y3wc3CMY2S0CE5Ukz2rp7UCrjBGGNc8Bw3X7j8czryZcGr0/RUMtaUMSrORU8oc/mQrw27daA66h/+6e9nbn44OteMCVA0cOnh8wJuADcIIVRqcBMMUDXiHJsANxj3kVWlCjbgBmOMcVFGVOW7SFPFnRdwgxBCqDvgRk/93mVMuWVMowO4wYAbwA3gBmOMMeAGcIMQQqh3wI05Fbq5gpU9RTrgBgNuADeAG4wxxhhwgxBCqBfBjTFbPOAGY8AN4AZjjDEG3CCEEOptcGMMlbJWHK8NzXIDuMGAG8AN4AZjjDEG3CCEEOppcGMsPe6F27jzE9tLiQNuMOAGcAO4wRhjjAE3CCGEeh7c5CTADQbcAG4ANxhjjDHgBiGEUK+DG3t2G8ANBtwAbgA3GGOMcbWDm+a6TFw3oETyV7F1lkepay7JKZpq9cIruam9vibjD0XI68Beu3v5X2Nep6htov+MUG4PDfPn749pMhbqdoc1WY8X5+lnDn1KBTe6cEQsB45x2YKbM299sLKx83z98guLVuTik9ufzIPy5Oyz21ZK5W+++sIb+xqkVbtP/LEUeAhjjDGudANuUtBD6ZQn1JB+kd99cjpjMV2pPnX3ADcI5f7QMH6SwVrdwXTCcYQ6NNlw5OmRuqpUOKe9E3CDATeAG8ANxhhjXNXgxn9jXFdrdB6a68Lvct1eR4NXUvok/ttjc3laX6or4lRbV+e/ZA56LF7NNXW14Ygbt3x9Q43//tmv0KjN2GvVFrxzdmDNcKfYoF8OCl5uu4uw1JttditsSuwRBV2vYtw9hZDq9RV12hdivEtXh+R693w4Vey7V1M7LvTXRAhlfxSoJ4CxVndAZMwFvCMPmThSzBw3GANuADcYY4wx4CYALsHL4QBqqF6ECxScrrubUN17t7fvHqI7HnE9EJdoBDUHPEJhCF2hCW7MluhKgtoURAjebFu1uXuDc5kRN0Gb9Vtu4wW47LXxhHNbchjAlePds/YameFEcN5c754Jbop894i4QaiQIDgTClu/wTAnDQ7JKeIGcIMx4GbL5OYVE+68+aqW9ZMANxhjjIvunVMv/uKa2l3T3pOtpPM9fO+MD6ffvjqaP/mWJQvHNPbwtSyb0LJ6Umu0hemXVr7gxu5jOOnQMBw3VqXTRjPeIXFjkfwXy+Y7ZK8SIxGu2UcVxqCDAGREatOZVm1uqwwIYoGbmMvUpCNxCENx7p6FZqKXGXoJb92N1Ltngpsi3z3ADUK54+8gMs5+2vg/Ny8z4KTerywySU0iuPFD5NwHV/zMxIAbDLgB3ABuMMYYdwvc7J3xYWGHr57Ues/waWUCbqQlVQVuEohGeOpLyTTiU2LBTXOdUV7DAmPokNszSUJCeqhUU1cKejBHNjmZodr8AiZLCjUvUtJJOJl2/8eMOinS3TNbFQduzLfxGftupN690FCp4t49wA1C+eIb+8cbO1uW99zId6iUH9/nF06a6ApwgwE3VQhuWtZP+sHgr8pDQbaAG4wxxsX13hkffv+bI+S/MrI1I24WjmlUHdSvf3aAfJx8yxLJVzkKxOiPcqAcpSqRYlJYDkk5MKkZP+4/5rLP9pd65o/aJkeZQUBql65Tt/kf/2e/1ZNa9RlVA1TLVUl9FYpJyVYdqPZWfMRNUiRIPLgxBxbFwYJcI27S0UNk5uCEmJF4cBOagEa/+q6pbzDHSYVehhfv7qWDG3M+nZi7kXPETZHvHuAGobwGS/k/5Ng5bsLgRn56IVgTM6lWyuTExoOX5cAx7hvg5pF7rxdLon7aiB8M/irgBmOMcRE9+ZYlipIsHNOoEIwCN1bQiuIvKrLmx/3HbJnSsWbSSQ1cJFNH3EgxVaGqWR8o9atECrhRZ5SSFriRhmlapPaadUpLFIVRbZOqVOMlc8A/3yAJVfnyBw5Z9VTOHDfhBVDsWVp0+Emu4MaNN0kGN0HJ2Dlu0tGD186ss7QkgBuvhfZoIGMum1xHSOV993IGN7qdud693MFN3ncPcINQDlE20aXoYlaVMn5NSVOD2QM2o0OlgkrUtFyhSDrADQbcVDW4ufPmq+qnjWCoFMYY41JYIwxrjpvVk1r/8X/2MwNnVDE94EgHs6iwFw1uosRHHZg0lio6jikKbvQuVVt0+JUZ/mOCG3Pwl3mK2AFcFbGqlLvsUWRdJGNehpShUnp8UE1DU1rMiFGzs0ZVnkOl6uylrJLWb+o0uYy/qlRd3fCMPZ2EPYYoJPvleeF3L9tQKV2+tikKYlLvXh5DpfK9e95e2A1COTw/Q6u/6YeJ8bTxV+Izf1PBMye6hl3sUKlMzDMKcINxX4q42fD06J8O/wbgBmOMcSkiblS4SnRyYitwRhVb/sAhRWFiI24UE1HhMIWBG/NcseDGbPOkf3tGn8KKuPn+N0eoA6WG+SO3VTC4qZjeUV3hCMFkH7FvsLl7CKFyUg6rSjFUCuO+N8fNv3z5Uwrc6BgclZAcyd/w9GjADcYY44LnuLnss/1NSqJjWKypaqxpZeSjHLVwTKOK0FHHWnPcmODGHBKVBG50DVaTNHCx5rjRsT8D/vkGKa8ab+3Sc9wAbioL3ASDm3IZEVGbiSqH9cIBNwihooAbd0hjrMIPN8ANBtxU86pShRlwgzHGuCiBOT2/OFQPG3CDEEKoG+AmGl/j57R3Am4w4AZwA7jBGGNcSeBGT6CjlTJvMeAGIYRQJYCbXAW4wYAbwA3gBmOMMQbcIIQQAtxgDLgB3GCMMcaAG8ANQggBbpTchd78NfgSp9kC3GDADeAGcIMxxhgDbhBCCPUwuGmqy9TUt3epWYp9fMOqUhgDbgA3GGOMMeAGIYRQ+YCbgNewHDjGgBvADcYYYwy4QQghVBbgxhoh5cTd1DR0dgFuMAbcAG4wxhjjPgRunAkUYt7flkidDTWZ4fWdOuy/BGqqje/YJMrvF4lyOjBhqELB7fWHQuTf8rxue20TvWKEivfY9BR5jjXVmZn68RL8AJ2nn3reqB9+FnCTmwA3GHBTRuDm7Yu/q2/+uGXHpLbDS2VruXXXTIuw7Dq/Z9npdUX3lrO7ZLv94Nv7D//RadWR4+ce++jcY10YY4wxNg24SQY3JVSe+EM6UX73yelixXSlegzclPa2A24QKtpv1n8CRJ6f8vwxaI6GOEGkjFNA/Rjjnr2AG4wBN4AbjDHGGHATCb+vNToP+jWyx1bcuJgGr6T0OlSfxOhsNAXvnVVXxIUadbWRd9FezTV1teGIG7d8fUON//7Zr9Cozdgbed3tMyAH1gx3ig365aAgdkaKDa+vN9scYi7RqSIShyFEwU20VZ1+jnONPiXx71jQZ/PrV3cg9O7d21vse1JTOy5jv/NHCBUL4oQfdLV1QY7xwDGDDb2HQBwpBtxgDLgB3GCMMcaAm6CzEbz+DaBGsHyJ28l3EwoEuFzAPUR3POJ6IC4PCmpWx7qZ+rVzBNyYLdGVBLUp3BCE6li1uXuDc5lwJGizfsttDNFyulhNaX2wVOYVd43q7rmcJa3NbrHmOp/gRIZKleCeEHGDUEkUgi/qt2w8Rlx23BmOzQl+tkTcYAy4yQXc/HLq3bVLHwHcYIwxLpG3j219YOi0Q5Mujh5Qe3Lyh/keLgcu+dkWK1PqkdpkV/ebt/KOxuk3LsmxeVJg/o9XR/OlBqmn8sCNGXjip0ODmLz+hoVmvEPixiKZS5/43RjdabF6Lza48cobcCGuNp0Z1xcKRh/Y4CbmMjUTsRiNWUmuXTW/MSYZ8dOh+J2gVXL48Jpw4E8U3BT5ngBuECqBQr9x/9kSgBv7oWpG3xjBcYAbjAE3RNxgjDHuZXDTTbBSJuAm6VoqFdwkEI1MSJJpxKfEghtjhs6MvWZtGGqkgRujMxMDKWzAEarNL2CypFDzIiVdbiKZ9jgpMz4lD+zlnyKOkuhhUBlrpFKYfMWCmyLfE8ANQqWgNsHPynuwhAP3YogqQ6UwBtwQcYMxxrgMfGjSxW9+eoD803PEFWPMiBvZqt6r/njTpSPkoxSWMvookeIp6uPKOxrFKQemtETq0RXKR90AOVzqscBNSuHDte+pM5oNU2eXHF0ySnAqL+LG7tungxtzYFEcVsg14iYdUkRmDk6ILokHNzFziLqDlRrq7EVecucaSXAqDtzEDLxyhmjVBzMiFwJu8r4ngBuEiqpgtGmXGURjku/muDluQrAmZlItwA3GgBvADcYY457w6AG1CmEoqKHIyN4JHWZgiyRuunSELiZ+5d6TisJsH9s64ooxJlgZ+oUbJFNyJH/jqEP6QH2ipBgZOVAhITlkx71tcgp1aqlH9prgRqpNL6wjbqSwIjuq2eoaVfyOSlTIHDfhJU7sOW50+Emu4MbttCSDm/DSKnmCG6+dWedzSQA3XgvtiBhjLptcR0ilgpssc9wE3Tw/0if0fj5fcJP3PQHcIFSiEVKxTCd5VSkr4sZmu4AbjAE3gBuMMcYltyYd0TludEiLDpzRpEYzkZSImOhQqfRhStHBTTpy5zN/1y8KbtIL69pkq67OGioVO5aqIlaVqmmor4uuKhUEp6QNldIvmWsamqIgJhIG4tbboIBFHkOl6uylrBJWUDIhRbCqVF3d8Iw9nYQ92igkH68kL9GdcI3+3XCXfIqsKhWNwQmPqLJXlSruPfH2wm4QKt7DMxRcEw9ujMLBry945kTpD+AGY8AN4AZjjHGPRtyoIJQoebECZ3ToiiYgVsSNlFSkRup5fsS23MGNqkedcdFPNyqwkhRxk17YpEvm1VUwuKmYDlJd4bDBJEfm6/LShp/ktqZ4b90ThFAZC3CDMeAmHtxM3zJn6K01i4+tlPT1I2+SfNmmAx3ADcYY41zmuPnGP/bXETd7J3ToKWysqWp0fI3aO/QLN4y4YowcpXIUGYkN1VG7NKBJn+NGt+ozf9dPyqupc5LmuIkWlrNIWp3amuMGcFNZ4CYYGpaDgniZxLfrkYCXUge2AG4QAtwAbjBmVSkibjDGGPfAiKpiLQ5VzgbcIIQQAtxgDLgB3GCMMQbcBFPSaEWXEgfcIIQQAtxgDLgB3GCMMcYYcIMQQghwgzHgBnCDMcYYA24QQggBbgA3GHADuAHcYIwxxoAbhBBCPQBuFhckwA0G3ABuADcYY4wx4AYhhFDJwc3FQgW4wYAbwA3gBmOMMQbcIIQQAtxgDLgB3GCMMcaAm5KCm/b6mkxdUzivs6EmM7y+s4BKooniqrkuv4YhhFBJJQ8lX3XNXl5TbZBnPQZlV01DZ8qxgBuMqwrcKJ3YMvnNgystRiPes+9Iw44u0+9c/N1b54+07Jh0+JVaq/CZ5kWyPfXK0ydXPSuJk689e+zVx/xdz5klX9zYtXJD15mG9889fvHwrsnvvnNB2nCs+YnDr045ffRFSb91+jWnSeuOnJvahTHGGGPtyoq4KRzcpPIgwA1CqLrUVKcfdA6FcdOSqG0KCE5tk0ltRD64iTsWcIMx4AZwgzHGGANu0piL9/q3pq5Wg5vO+uHhF8Ju+bpaM7OpTr9b9moLcuYZr5c7G2qCV83qzfPwGt2N0e+o/TLOqesa6mvMzADcBA0zUU5TrfX6OtJ+hBAqFcSJPGcCIuM+i2qbQhE3qccCbjAG3ABuMMYYY8BNdJST6jm4HQyXhgSvi53uR019u1csQC0KmqQMlQqhFrcGE7L4zCWI8bGaEdTmHuvXZrzHDjo8TiUq0z97TPsRQqgU0o+p1OjFeHATdyzgBmPADeAGY4xxxXvJiC2Hai+uvLPxiZuWSGL01bUnp3yY47FyiByojs1aWCqXcyVVUj3gxhyF5KXNl8Bu/EtzuIOhD0mb48YfDiA5kQ6MD1+cynVnxu/YxGXGDJXyGxYkYl9iR/cihFCxFHpepeCYOHATdyzgBmPADeAGY4xxpfvklA9HX117qPaiZiulAzdJxaoM3ITeDBvgxpTTtbCGVmUHN05Hpa7ZHicV7sAY456UHKATQi02uGn3hlBZI7ai4MZuP0IIlYDamHPZdIWCB9PBTdyxgBuMATeAG4wxxr3r0Vd705BIQmER/VHhmJsuG6E+PnHTEknIR8nXlOSVe1sfuGaa3vX8z7fFRtyoAiLFXPRJzdo0kUkpvPfBjm9+eoCkpbCcRaVlK2kprEtmJTgVG3ETGV6UP7hxp+qst8ZJRcFNpIdjvoX2094Z7V3JETcMj0IIlVQOILahcPLYzDC4iTsWcIMx4AZwgzHGuHdtERb5OPSLN7xyb6vkjPj2mE13H7rpshEr72yUj5J44qYlKl8KWOBGR9zEDpWSMlKtZIqlnh33te0Yd1LF6Zi1qWOzFtZ8R7EkBXqUNXtSiQqfnFhHrMTNcaPfHhcAblTkS2Q1qKbwvMV+Ad2TCZoRmePGADfuhMqK14Rb65SPaT9CCPX4CKkkYJ0SBgi4wRhwA7jBGGPca9bhLYq8mMBF4xgNTSTzgWumFQBupIw13Emd9DN/1y8KbtILa3CjWhIdKhWtocJXlXLXcoos3uR1MGLBjTcoSa8qZeREGI1OW0MG9IJQ5sQ3dbV1oTWh9Bn9poZXaYmuIRVpP0IIFfP5GZIaFmrlNcWCm7hjATcYA24ANxhjjMtrkpoR3x6z+q49N102Qk1VM/rq2ud/vi0F3Ch6osJbsoIbOVw+qnoW/WyjAitJETfphc2IG0VqVBuqBNz00FCCAoYsMZ0wQqjvCnCDMeAGcIMxxrjXhkqpaWJS5riJBTfiz/xdP3d+mf4q4uamy0ZIVQtvfckEN5qtmNPW6JNKDVKtAjFJc9xEC6sWmrv0HDeAmxzfSBcU7QK4QQgBbgA3GANuADcYY4xxj7hvR9wghBAC3GAMuAHcYIwxxoAbhBBCgBvADQbcAG4ANxhjjDHgBiGEEOAGY8AN4AZjjDEG3ABuEEIIcLNxfCZJ4zcCbjDgBnADuMEYY4wBNwghhMoo4mbTeMANxoAbwA3GGGMMuEEIIVQm4Ob43GuzBNoAbjDgBnADuMEYY4wBNwghhHoe3LhDpcZtZI4bjAE3gBuMMca4j4Gb9vqaTF2TkdFUm6lp6PQ/ddYPV692a+rb6UkhhFBYzXU6AKauObSns6EmU9sUfti6MjLlees9YYOnbkrETXiam2vnHgfcYFwR4EZ05uwHKzd0WT7Q3GQClzdeWyYlT134oL6568Wd77avmmm6dfUHh+Z0HXv+o9dXbX7r+UUdq04ef2HV7r0TxSf3rFx2ep324XldUrLj6P+To05smfLexXcUuHlx7/s7j/9JtWd92/wDx5YZVGhhlCvh3vLpzWtPbH7k5MtPtq+ca30NMMYYl9SVEnGjehG6C+F8VH0Mp3MS4jsIIdTn1VSnH4zhh6RDbUKMpqnOIzsODVfPWKfM8PpOb68Nx7POcbNxHJMTYwy4AdwAbjDGGPcFcBNE3LjBNbVNRsRN0MFwi7n9Crd8XW38G2aEEOrDEMd7JDrIe3h9kxlxY8Q2+rxGHrBpkYysKoUx4AZwA7gB3GCMMeDG7k7oKBsdcRO8ENYvk91of1VAdU466a8hhJCm22bQjQY38gjVT0vvcepE69Q31OQzVCoPAW4w4AZw0xPgpnnFhDtvvqpl/aRS8ItH7r2+ftqI4p5iwcO3SIVZi8l51dP5B4O/mnJq2SVty6VCwA3GGPeWjzz3m3tuHHxq2eNPjrr5xcmjqxLcBAH/usthdk7MrghCCPVdGfGJceDGGBVlght/LFUE+gBuMAbcAG48cFPECnPkLFLgB4O/qopJG8SAG4wxrgJwU70RN4lDpZq6ADcIIRRQm9A8xLlG3GhYE8N9ADcYA27KF9y0rJ/0g8FfVQEpCtzoEBX5qNjHT4d/Y9C3Py85j9x7vWTqXfJRlfyXL39KismBA6/4vMpRiERV9U+f/O9Sg4642dFwb0qF6qNIgR59Cl1ATiEVjvnZQNXmZx/5qdQmOaq2DU+Plo9yFWJJyEcz9CYruFG3Ql0O4AZjjMvEp5Y9/q8DLpfns2zNiJudMx/47P/+H5IvW0lLzs+HXaVypEBFgpvQS2C/XwG4QQgh45FZFzfQyQY38XPc6GnCcgU3x+cNCSa22QS4wRhw00vgRseh1E8b8YPBX93RcK8VoiLpQd/+/IanR0viX778KcVfnJL141586k5VyZ03XyX5qoaW9ZMUPdFVKTZkgpvYCmWrwI1UqGpYNedOKakao06hW6sDZPRJdasUr9EER1ObrEOlVCP1uQA3GGNcJn5y1M1iSbw4efS/DrhcgxtrwJTee+S530iiKiJu3D4G4AYhhLoSgUs8uElaVSpYti/7UCl3GanxGy8en3vtkLlHZJvJjNsIuMEYcNML4EZDCkVVVs25U0Wv6DgXPYRK4xUNTTY8PVoXVuBGURVdlUYn5hw3OxruTapQj6hSOUufuP3eEYNNwGQVUOBGx9FIYWmSyjHhi+ZBOY69KuLALsANxhh33/fcOFgBGmuOG/n4rS9+xoy4UXxH/NBPaip2jht3FgZz7sxYcBOpBCGEql8u0TZlLrQXBjdGYSOzKXmFvrhVpdTqUQrcmDmAGwy4Adz0UsSNFSYTnfvG4iybnrlbz4mjI25McGNWpQrkAm6yRtxEwY0ZcSNblTAPTBkhBbjBGOMKirjZOfOBnw+7Kjo5saQV3KmMiBuEEELlpwi4cUJshsw7rsGNE4Bz7dzjgBuMATe9OMfNv3z5UypARs9xo2aNSQI3O+rHqQNVYI6CHSa4MasaeMXncwc3alocNT1NdI4bDW7kWGnz3Lqb9Rw3mrZIYQ2AzAAicxKcrOBGl5S0qq2AIVSAG4wxLuIcN9/8wmdMcCNb9XiPznEj6T4BbiIvn0PLUSGEECoc3Fy8eGTuEG+olPt0TaY2gBsMuAHc9NCqUuXgAkJdYqccLuIkNUTcYIxxpdgcKlXWq0ohhBCqCHDDqlIYA24AN6UANyoSJ30eYr3clalchlMBbjDGGHCDEEKor4Ib5rjBGHADuKlGA24wxri3DLhBCCHUDXDjj5CKKm7MFOAGA24AN4AbwA3GGGPADUIIoR4DN9H4Gj/nyHHADQbcAG4AN4AbjDHGgBuEEEK9CG6Y4wZjwA3gBnCDMcYYcIMQQqh8I26iYo4bjAE3gBvADcYYY8ANQgih8ou4OT5vSGbcRiJuMAbcAG4ANxhjjAE3Pa72+ppMXVMoq7N+eKauOVysuS5jF0tXU12mpr7dTdVmaho6zRyEECreU0ueLUrGE8Ypo6RLOk82u1jO4IZVpTCuJHDz9luno/3z85tXts/bqX3hpUOq8JHdjx3aUduyY9Kxl+tUyVONC15vnC45e/dvrW/ueuX1P//2jd8fevYtf+/813c/IXsvvtsph594+RHJfOnYB60X/qAbcOrw8sOvPqw/nj35cvOebQ07upQ3Hv3L4pYuXCZ+6XjH0p3/taLx4/MzP37zyY/lL77qwO82HfvNrranZYvL3Gc3b7pQv+rCohWrTh1qaNv/0pEl3BOMK8iAm+6Bmzh1A9wk5yCEUAGPLBvHuGjYfUwNr+/0UY6iz50NNZnaJkWQVSL2acYcNxgDbgA3gBvADeAGYwy4CShJfUON8dY3FN4iXQsvrV8Xe/0Q1dkwc9wDG7xi0m9xuiVBf8be22VV4vVq9JtqsxtjNMlvRl2t0dWJbUmtn+l0jUJvtt2Im8NBzj4TFUkD8uJBCKE+LOfhU1PfbDxD5BmlH5JmsVrruWLwHeexZkPknOe4iY+7AdxgwA3gBnADuMGAG4xxNYEb762v8x7Y7W/oF8IGxYiMM3IPdGGKy0Q0HFE9FpekuH0S3TlR6MStTfdSjO6KPnvqUCkH66iujkuFwrUltkTtTRkqZYChmP4VQgjlHCfoPEPqrTFQ8nyraai3qHTw0CPiBmPATZmDm9t/veTBhY1FoRKzX7l47+wtuZR8dFXrTXdPA9yUCbhZvvuhyfNvzfeoNfvr/u3O/nJswecdO+WGqYtvz6udckY5b2z+C00PdbM9gBuMATe9B270m14fZOg3xppiBAH/xgvkUOiN9DqsF8heP8SnJMbeIDOuwhRw0x5+re2mg85PUIl5Lk1n0ua4cbtVnaEII4QQKgzcmKOiNA03nj+aDneqaMdohA7gBmPATbVG3Dy4sPH2Xy8B3FQcuJm6+PaxU27o+fMCbjDGgBu7vxGKQPGGFFndjwClmDleJdaAphhwY47AMgJnMqGBTingxnwvbYKbkMItyQ3c+KyKcVIIoW6Dm9Cz0XnIGGGMSaQ761ApfyUpPUpqE+AGY8BNz0bciAffPOYTn+4nlvQllw2Qh5EkZr9yUfIvHXCDfLzyuhHP7PlQctReKfnoqlbJkQKXXNr/G0Nv/tzXrlJHmZWr55oCOvpYOUSBGymsClz3i1r18Wv9f2AeIvlWAf1RTi1baZX6qM6lGmk2QNUg55Vj1QWqZqsDrauQzDk73zN3aRoljZeqZK8uaZ6onMHNmv11g67/mlzRJz/93+evv0d9VMTk3+7sf+eD3/vyv/yj7JUcsbq9kq+Azreu7qdyFNmRfF1AR9yIVQ2qfvko9UtaciQhxSRTfVQFLHCjm6faoPLVR6lWatMFZKvOaxUA3GCMqyfiJjxwyQ3sj+uKpEbcpIMbPwrGTzeH56kpOOImbvKI/MCNYlUNjJNCCHUP3Nhp9yETfWCGYE0oIDEJ3Gwcpya1cXVk7pBMZsi844AbjAE3PQpuFIlQ1Gb2Kxclcd0vaiVx6YAbHl3VqhiKylQgQzIH3zxGgQxVwIq4UQUU3dDHKqyjeIpULieVrcpRLVHNUMc+ublDARo9FEs1RnGWycsOSWE5RFEYOVzlq8aY4EYlVM3qRMqqTsl/clOHPlAfohscBTfmKcof3IydcoPCLgqpKBTyb3f2v+3eISpfRdzovfoQydfkZfgt31qyfbwZ8KLBjWxVPbrYtwb2U4RIPkoiKbJG5ctWcSLVgPrt9z+18i5VQPJVAd1OKfBC00NWAcANxrgK5rhRHYZIEE0Qz28yHS/OP2GOm3RwY6AZvzNjTF2cwxw3Qfcmbo4bN9MfKpUnuPEidxgnhRDqXuhi8Pzxn0hWPGPwwDQibuyHT9zkxNYkxCwHjjHgpsfBjcITilbo0UyKVih0ospIpsIWGnkoBBMFNzo6RulnE5/RyENVLttPfLqfLhClJIqz6L1mY8Qq4kYyTV6jm2fN4KNJjTqFDuRRkTWTlx3SV2FN+hMFN7pkpYAbHSZjxrwoyKIojIIjOi5Gx9ToIVR6jJIOdTEjbm67d4iqU5GXpzeM1XxH7bJCcqLgRmEdDXrMlsgu1RKzGVYBwA3GuAqGStXVpi7kZEzckH1VqfShUv5KT37NxmJPwbIsamEpScdNHtyu16UKBwRlIitYNUfHf5mrSnWaOV1dOS9DjhBCaeCmK351vOjCfEGxyJxfMeDm+NxrwyE2m8Znrp17HHCDMeCmHMBN1oibJHBjRtwo64gbHc6jI25iKYnJaKSqSYv36PKy97552woGN/qjxYDMkqr96iyx11txETfmpDCDrv/ag0/erIdEWRE31tw31uQyirA89eLIpIgbC9yYFaozpkTcmNzHiriJ1k/EDca46ua4ySG/cEVIUJkpbsgVQgj1juLmuHFWBPfYjTNUasjcI8xxgzHgpjzAjZ7jRuVH57gxwY2em8aa40bPmKOOveTS/tYcN+pAC9w8ublDlU+Z4yYW3GhmlARu9Bw3avobM27Imv7GbLMJbvRJ9bn0rSvbOW7UpDBPbxgrWz3HjaInahYbPceN/miCmyXbx6vAmaxz3FjgRsfpqAI62Cd2jhvzo2qezvnS1/9RDnyh6SGrAOAGY1yF4MZYFaWPgJtg4BVCCJUpuGFVKYwBN2W5qpQV+YKrclUpDLjBGHDTm+AGIYRQRYCbTeO9xaTcmYnTF5YC3GDADeAGcAO4wYAbjDHgBiGEUI+Bm43jvbFRzmQ3Pr5hcmKMATdlAG4w4AYDbjAG3ABuEEIIcOOBm4DXsKoUxoAbwA3gBgNuMMaAG4QQQmUBbqwRUpFFpgA3GHADuAHcAG4w4AZjDLhBCCHUa+CGyYkxBtwAbgA3GHCDMQbcIIQQAtxgDLgB3GDADQbcYAy4AdwghBAC3GAMuAHcYMAN4AZjDLgpQO31NZm6JjPRXJcZXt9ZQFVyoKOa+vbovs764Zm65qK1urOhJlPbFGo/Qgj1jCKPneCJ1NXVVJsJy3+u6s/NgBuMqxzcvPHyoTrLJ85uO7Tz39/57Vmr8IVl686smr3jlY171+5+6/lF4s6tG88f3egwmt1Py/bNAyul2MHdU6VbKG57+4J5+Lmn/nrusa7fHv6DmdnY+selez/WH1su7Nv25lqPE7065Vjzk+d/+/v6pi6NcnAPeNmuv+7eO7FpTfOhOV2H53W17Ji0fMcHkr9kf9fGPTvk47K9f97++p/X73z91PbZFxatOL9zjQn+Tjc9oxIntz8exYLpbts500m8/GjSsSdfefLE1iltO2f753rWydw2TYHCoOTLj0aOfdg9/Im2nU+po069OtepzWnn9MhZZpxuWujxR+e7/fDJbVO9MzYvVIers6tT+yUXSNusCtUpwvfn2db1s849fvGt5xer35Hjl9YEadPrVzs/tI3rLrywWm614+dWeolFK95a97JOO16zOSiwfP356e/IWbS3ndiz4syGZafXdbz71tuvHX7y2XcmLOrCWT179dvynT9wYMsLW7vkF4Fxb7lSwY3JXwoCN9J1qWlIOg5wgxCqGmrj4xj9OBLVNsU+99ynYlOdLu8QHPuRBbjBGHADuAHcAG4AN4AbjAE3EUbj0ZmmOv1OOC3ixul+KGk04/VV/BCb4KPqvejXy15VLrhpUB2eoJK4t9DZzxUcVTsv3P6amuGZDBwHIVQiOQ+fmvrm4FnqxNcMr28yIm6yQXDnqWtRbMANxoAbwA3gBnADuAHcYAy4SQI3OQ2VMkYB+O+NjZfGTr/F3RuOglEDplwK42S6CVWt6vm0m8XcY929BZ1Lt7+YQT0IIVTAUKksYYbGcw9wgzHgptzBzcSZjXdMWFIUcrFo84d3/3p1LiXnrb34/VtqpTzgBnDTp8DN3bMufqumdtz8D3uSofx4QuOwny+RxA/HbJEGAG4w4KZawE3aqKVQQtfg1aaHDCgiE5kHxz9pvucKtz92eh2EEOpxcBMfbmM+CQE3GANu+lLEzdTFrT+6YxrgBnADuCkrcKMsJ5VTA24w4KbSwU2XMd1mdECTHh4Voir23Jzmy+cA3IRm8fRPmte5YtqPEEK9DW7kORYBNDoCsQtwgzHgppIibuatvTj0xjFf/84N8qiSj9+/xfmXmmIrsv3ONSPk4+e/OkCKSY76KJJj5aMceMlX+n978E/F6nCzclVSKlEhOepY2arKrQJSv+z6X/+3nypjFlBnF0tCf9RNlY9SUg4UT13cqhuQUkB2qZpVg2V72ZU/sA4H3ABuig5uLhs05rOXOj+0L317xLj5H0rOJy9xvtKS/90fTjPDZD77tR9IvoqXUd9VFTgjOVL4//tEPzNHFVB13j6lVe2VraRVDaoSKXDPU+/JVpWXXVJeavvk5/pL5jeufUByVIXfqqkF3GDATc+AmyAoJr9VpTzmYsbUxEfcpI0a8MGNOUlnzElzOhfgBiFUfuAmGlfoTG2TNH074AZjwE25g5uvf+eGqYtbFRmRTMVQZq3okK18VGhD2YQsUmDojWMU7LAiblQB2ZrHKkoiFcqumS90WAV0MxQPUhWaJEVOrTmL2RhJKNCjT2GCm2gBqVPqVyE/UkDdhG4OGQPcAG5yATefvfSG26e0KlwiiW/V1CpWMuznS0xWotGJlJGSKkhHFRZr6COJXzzSpupUlSirOs2hUjriRp9IHX7X9A7VEvOkulWAGwy4KSW4UfTEmHEmB3BjvDr25p0xYIo7vXHiHDfezJ2dWcBN0J6CzgW4QQiVE7ixC8SPkALcYAy4qRhwo0JgNG1RsTazVnTIVrEVhVGksOI4iq1MefqQVcAcOaViZ3RMjUIkeqjUlGcOWQXMIVQK2ehKVIiNxXF0Y0wkZIGb2AI6kEcH3eiSgBvATc8MlfruD6f97N8P6eFLt09ptSJurGgaHXSjd6lKfvLgHl2nIi86iseMuDHBjYIyCh6ZbVBlVERPN8dzAW4w4Car/EFMNfUNdSEaEreqVJihWMOXjOWoYqenCZaLCtBMZKiUHgNlrtKS07m8+p3TRdqPEEK9C24s/O2tIJ6JLKIHuMEYcFPh4CZrxE0SuDEjbjRGUfREBbyYETfRuW+ijEadWjVGtir6pjBwY0bcWCUBN4CbHgM36RE3is6YETd6V3rEjRW2kzXixpz7RvZ+9ms/MCsB3GDATYnADUIIoXIT4AZjwE0FR9zoiWkkMzrHjQlu/tf/7aewjjXHjYpq0cde8pX+iptYBaLgRs1QkzLHTTqXSSE7eo4bdSG6pGJDeqxWFPEAbgA3RQQ31hw3egiVGVaj57hRs9KYc9zoKWnMOW50eSviRvbKue6a3mHNcWOCGyn/yc/1VxgIcIMBN4AbhBAC3ABuMAbclPuqUiaXwYAbwE03wU3UZsRNjnEuJtMpuqMBPoAbDLgB3CCEEOAGcIMx4AZwA7gB3PRRcKNXgPrkJQNyXKu7dOBGRe50c1piwA0G3CCEEALcYAy4Adz0HLjBgBvATUnBTbUacIMBNwghhAA3GANuADeAG8AN4AZwA7jBGHCDEEIIcIMx4AZwgwE3gBvADeAGA24QQggBbgA3GANuADeAG8AN4AZwgzHgBiGEEOAGY8AN4AYDbgA3gBvADQbcAG4QQggBbjAG3ABuADeAG8AN4AZjwE2SmusymbomlRhe3xlbpr2+RpXJTU21mZqGztL2b4ImNdVlaurbcz8y3/IIIZTLg1GeLa6MB6k8DJXMR2JsJuAG4yoEN6LjL/8m1GXd+7T0UqT/+d7Fd6KFjzZNP79y5alVXg/5+N45b2xa7nQgN76iyxxpfOzcqR3RY08dXi41t59pMjPPHn6p40Rw7Ltvtx959Tcq3bF+Xsem5y6e73B6oaudHumeowsaDyzd8VyX8r51f9Fp7Y41s9tXzTy3cdGSE2/see1AfGc44gvbVnS8sMDr/b68SmroSb9w5KPFLV2966WHP5at3LTVe//csKNrTfNHexb+QXr7J5b/+fTzm1U7W1+aI93+l04u2nTsN+3n9h9dvfTNuX86NP/DnTtWmNxnY8t/1Td3Pb/n4/rdeTOjtXs/kmOX7v34+V3xBVa89teGnV1r9n2kPm5o+YuUf2HfX2W7zk0rL3v14wiN+tgp+dpfVx3464bDTgvXHPxo1QH3dI0fR8+ysvmv3uUc+ItsVzb6H1v+sua14OzL9gTHbtj/F2mbJF5s+qvOfHHvX63KVZtX7PhAvmzLd3ade8zx+efeb3tmr/xAjq5e9uKpZ7U3v7Fe7vmhdR+8cvSwJMT1J954Y8a7isVsP7pv9+ZVp9bNU7/HlsbtKzd0rT380u69Ew/smXHu+cXB77p5vlS+etOfnt//pgNVm/7w4p5mVWGJvLqtafmRRvNaKtFbWo8v33dWvvDHjx57fcE7OT5PMC6FKwzc5NE/AdwghKA2GePh2Vk/3HvuOVymtsl7uqqEy3Tqmt1yDTU+2Yl5FgFuMAbcAG4AN4AbwA3gBmPAjdXryNTVRiNu/PfGGb/7YYKbZn9n3Ftl6Zk43ZKEl8kxzMivxDnK6OG4p64LejV+azMBrFEaN3G4dzZV0nqVbSAkp1tV1+xszfIIIVQQ766pbzaJtkFh4mi4/yySR1DawwdwgzHgBnADuAHcAG4ANxgDboKQ/uDlcAjcBO+NXVzi9jE0uNE5bjGFWgLm4hfLNeImDtzol9UuAFLnCl5WO3vVIXERN8GrbBf0uIf43aTmOr9JRNwghIo9VMpOWw8Z/RCTRF19Mt0G3GAMuOmL4ObFyaOfHHVzD4CbZ/Z8eN0vame/crEoOObXS1seXdUKuAHclBu4mbx0vPxj4sa7vlcswjJy6m1S59Kjc8fN/hXgBgNuehTcxPY3Yua48RmHX8YI8g+BHkVV8h4qFQNuTKrip83X1yGEZIEbAzmZbZCSw2viX4wjhFBRHqT2Yyp4yHhBiGY8Y0C6GSqFMeAGcFOxETc33T0NcAO4KUNwozhL0QNkZm5++CfjbwTcYMBNj4KbWBSiMUpzMFIqEwU3IUlmEA5TBHAT6smY4CaT1CQL3ITkjb2y2gO4QQj1cMSNpt7m8yfEmgE3GANu+nrEzZHnfvPzYVddc/mX5TkoH++5cbAkZHtq2eOy/dcBl8vHb33xM1Ks+xE3t/96iSSkwksuG/DgwsZPfLqf+NFVrZIefPMYScsuKSOHSI76V+WV142Qw+VYSUiBK753qzo8l/gdwE1fBjcLXmsYemvN14d8U74wV9149eJjK2uXPvLLqXerXdePvElyZKu+ZpLoJrhR4TaiSc+NHXDjFSo9cupti/bNGHbrwMuHfE19vPGu7+moHNn1hW98Tj7+wz/9/czND8tHOVDSkiOJpUfnSnldm6oqtny+MT6AGwy46V7EjQli4iJuaq2pG4oTceOPkEqIuIkud5UAbqyWeGeprTfmlQDcIISK/SDNNseNn2k+pgA3GANuADdhcHPN5V/eOfMBSXzri5+RTEn864DLX1tQJ1v5KCWlWL6DqlLAjeRIQhEZSYgfXNhoAprH1rRdOuAGFVajCqh8BWuIuAHc5Ahuvj7km9O3OH/f60feVLv0EQvczG5cqPBNcSNurACZRftmXD7ka4qzfOEbn5MCCrjI9sa7vieHqJiaYbcOXPDqNFVy6dG58lESVoXR8qoeIm4w4KYEc9yEF0BJADfBLDMxc9wE080ES6j4e/MAN8YsNrnMceNmJg2VspZrUW1wZpTwyiev5IIQQt0DNzGrSpmkOyYzeAACbjAG3ABuXHCj4msUr5GtirV5bUGdbFWgzc6ZDzz0k5qigJsHFzZqHKMia1Sm+qi4zKTFe6S8HKUKqGN1DuAGcJMjuNFcRiGbaMSNfCxWxI05VEqF1egwGfm49OhczWskLTmS+Mn4G2dufljBHdk1a+sUVVJy1C4L3KSUB9xgwE1puhxqdsz6uvBQKWNZqCbv5XDsqlLhHoteVUrP6eD0YbKtI+4vAuXO1hleVcptWHRVKTNwJqPfYEdXlXJrC8Xg+P2lUHmEECoGuAmeXbEr7iUtw2cJcIMx4AZwEwNuShFxkwRuskbcAG4AN92PuFGARjKH3lqjY20kIR9VySLOcWPhlSi4iUbQpIOblPKAGwy46YudotjhBgghVL0C3GAMuAHcxEfcqDluZCuZ4p8Pu2rnzAfEkpCPUoOUKQq40XPcqALROW40uJGElJy87JAc8uiqVrEkZJeKzQHcAG6ic9woXiM5/b7xJfn4+cu/KLtmNy5UH3UBxXc0x7H4Tu5DpdQ8NVkjbqJz1iSBGzWRTVJ5xXHMhByVMvEN4AYDbsryvXRE0WlrwsE7BMUghPo8uNm1YGKSFuwC3GDADeCmL6wqpfBNvnMSF7aqlDlUqogG3DBUKq8pbLoZcVMpBtxgwA1CCKGqi7g5sXLatJXHNdAB3GDADeAGcAO4AdwAbgA3GANuEEIIAW4wBtwAbnoR3HTTeYGbEhlw05fBTSkMuMEYcIMQQghwgzHgBnADuAHcAG4AN4AbDLgB3CCEEMod3FwMz30DuMGAG8AN4AZwA7gB3ABuMAbcIIQQKkdww6pSGANuADeAG8AN4AZwgzHgBiGEEOAGY8AN4AZwA7gB3ABuADcYcAO4QQgh1JXrcuAxg6QANxhwA7gB3ABuADeAG8ANxn0S3DTXZYbXd/bEmZrqMjX17ZLorB+eqWvuXmXt9TUZR3Vr/ERuFXY21GRqm+g6IoQKkPMA0dJPEv9xJM8h/XBpqlU56qGXX8TNiRenTXx6FxE3GFcMuFl3bIXZ3dpz+NW31m9LKty2c9bZw+taTn2oKMnWto2tvz1mlXnzwIqOk6/GHv7mgZUX2ppTGnPx7faT2+yb1rlv64UdK9qXXHxr+0Hp6646tfHka/Udrbt+u/8/zk3t6lj3vvRgX175n4tbug6e+8/ms9vkH7idm196a8P27S3vtxz6w/Jmp3++q+Hj9vk72+fZ7mjYc3hn3ZHdj8mJLjy38uyqV/fN8/rSr20IQEAp3Lrqd06neuvDzqnfPrXt8OSXD9WZXn/6+YI7nC+fWS69TfGG7f/VuPUvFqY5sv4v6hrFZxf8P6dj/8qTb3e0vXv+jGI0F7Y2bN524vCZD95944R87HhpvvpbnGvbJv3/4/vmnu38vVzCoV2Tz76+2QR/4iPb2vat3HN048LmZSetXVl9/JUX5Xt1fOsTJ7ZOiS3QtOIvr2+afmTzq+rjwU1vNy9rPbZlmRzV9mrDvt21h7fXOW3YuNg6sPXlqVKmcflfj2x+5ei2Y5JuXvVR08qPJNGybo1V+OSOGUc2r1fp119pOr556sntj6uPh7acO/ryDv/sv2164V191OmmZ72r2PaMzmzbOdOq/ODm36qfz+q25+r3/HnloTPqT3Zu6Yvy9T43+7eq2BvrV8l3YFfbEtnV0Hpm6xvbJLH8SJPc9tdeXrj/1XX6i7Tu0Pam5inqjm07+uzulxvebHhhzYlnjq5bqWnRywf/q7H1j1J41+Ym+YPub/3dxhVdUe5ZRL/y0h+XHPx9SX9BPeCmbX85NKdr67HO/UcvHlvanu/3GeMiGnCTP7gpUrNVr0kncu93AW4QQoU9xWozNQ2dkSebB47148VJqOdqc51Jc3IEN0nTEgNuMOAGcAO4AdwAbgA3gBuMqw/cOD2K0Hvg6JvhANw4gTAZM3rFKVxTMzwT7Xgkn8h4Cx06u668pr7di7gxu0ABT4l7d+12flwFfSFXVw6PzzdQlH5D7pxLF3DOFVxvpCeGEEIx4DcmWjCOHRsPtwDr5ANumOMGY8AN4AZwA7gB3ABuMO4T4CboY/hYxOlCqO6EE8avYYebCOWo0BiXoeQwBMk5kddLcVmPNR7KOHt4V5gZuYWDTk7QnnCdQaBNuP1ZivlnD70S97pbsquOIByEUM4oPCDL8iSpaagPI3KT7xiPxxRws9Ob5WbaiyfSw20ANxhwA7ipeHDz4NzGX0xc0pPgZunRuTfe9b1F+2YAbgA3JQU3zz3S+n8+0U//S2HolSM2L/iw1ODm2R0ffv9ntXM2XSwibZHapE6pGXCDATc9AW4ckBHmEWaOxhwe2ojraQQoJP/xUNGzR8GNrl8XNocV+JnBoINYXuMnYotFxzXEgRuEEMrxoeo9EjVZdmP6jEwfkecDbpzJiR1kc3zltInTVh5357iZtvIE4AZjwA0RN0TcAG4qC9zc8cNp+uMt19XOmNBYiRE3gBsMuOlRcBOdWyGU42MUj3GE4vk93hEDX1LOpeVXmxXc+ImAoYTq8aoKzQaq32nHghu7WEyXyeQ1/uyh3Z4pGSHUVyFOCAF7z718I26CEJtdT2cPugHcYMAN4KYaIm6kZzj4pjGXffcGeSDKR+klSkK2pYu4mf/qNNkOuPEKOZEkRk69TRLyUfZOXjp+2K0D/+Gf/l5yJB9wA7gpLri5//YlqsshidJF3Ig/f+kAOcsnPtXv0aWtJny56VfT/n/23sQ7juPO86w/o9/s7szu693xeN90z+yb8bbd4+7tdfeMpn30c5eNbWvcb/qwx267ty+/9rbbdo+hUlryQUGSRcmiBIqWxCxSJMGbFEnwAkhWASB44CAKB0EcBbB4ALJlW7JFHdjIjMyIyMyoA2ABKACfz/s+KJGVFZkFEPEUn/xFpNgj/tA++Ht/JF79y4eyYkNekix/E6+K/XKP+AtF3BDEzRqsuKlF3JjSZzEVN6FGyWXCt9tWSraXxljFTaWVJiq0VtdVkwFgo4ibqEQ25Phi17jRj5HqaPU2vNIbxA0hiJv1Lm4+9B8/I4eXYrQpx4of+eQXFzXjY7Hi5oEHf+eRnV8X34qNv33sC2Ljk5///c3HHxU7pcF5secpsSEnVSFuEDf3OVXqzz+VkTs/89GvyjlTi6rBWay4EV+VhfnYZ7/61MGZpLiRB4g/N/G3Jl6SR4qNb794RR4pXlKtIW4I4mal1riJPuskLKtZ5Bo3ixM3xqwB69kTjwMPliI264DMpvz9tukJFde4ic5i0GvcRKp7oiMr1rgBgBpKC0NHE86KiivpJT1VqjNY4cbAr7tB3BCCuFnX4kaODJWvWcJSHUuouHmx5ynla8RLf/b1B6W4UYU2cg/iBnFzPxU3B56Z+8RHvii+iu2nvnnenBJQe9HNYsWNtDNyopP4m9q0azQpbsRfn7nOlPozFBFvkVeIuCGIm1V4qlTyCU2LfqpUcJjtIbjRMpbg8Uy5hJSJLNhpPlVKVfdESmD0u4wqGD2FKnHZ8dvd8SdSqflQwfXLY8J1KJgqBQC1o6dkmrWBqtcydoY9j6Waj6dKEYK4Qdw0nLih4gZxU9+pUqrQxqy4WdbFiZMVN+ovS3xbWdwo6UPFDUHcrNLjwAEAoLFA3BCCuEHcVBI34qscXsoNNexcVnGj1rgR26xxg7ipyxo33/jSdjlbSq1xI3jqm+dF5H45c+p465uf+ehXxXvru8aN/AuS337w9/6osrgR38rLE3+MYo+aZhX7G1RTq6TfQdwQxE1DzxRIwrOZAACWLm4sU6WaWeOGEMQNT5VasadKmVOleKoU4mbJ4qa+WcXHgdcxiBuCuAEAgHVZcdO5tbm1g4obQhA3iBvEDeIGcVPN2nzkk1+UKw0jbghB3AAAwIqJG68Gp6WtgLghBHGDuFkZcWMN4gZxsyYqbho8iBuCuAEAgPUpbngcOCGIG8QN4gZxg7hB3BCCuAEAgMYQNzwOnBDEDeIGcYO4QdwgbghB3AAAwBqpuOncirghBHGDuEHcIG4QN4gbQhA3AADQkOLGr8FhqhQhiBvEDeIGcYO4QdwQgrgBAIAGFDcdrTwOnBDEDeIGcYO4QdwgbghB3IQU3XTKyd1XEyW3KeXkV300lHNSabfIqBAAVqC3MTo9rxf1yYRdad5JhST7xlrWuOFx4ISsJXEj6D//fTEaFxm4sKnv3KN9HU7l42cmesTBbd1vtJ18b3j057Wf6PzgL6+MvVGvy7459boYe1su7+D8zOH5sf7d09fPi297Z3JixDv7yst7ekptRxdUbmTf9rzPq/lz5146PXra00az04G22HV4du+rYhR9+eiWpOuJxP2pMiA1Zubgs/Ish8Ze9t3K9+VlH+15Ww2zZW5M/nTXYCE72ruEHB6fvNb+ffH/+jfv3t01MvHa/JzYHjvfOtD5SzGo7jn5i8OXA/cx0bv7+sBe8QstzRTmip64eW1+vvyvvnfk8svq253d7/XdeON230TEhe2/5H3ddn7mxfNVfnpJj7az29t44VzxpQv2A9z8zPOdM7t6IufyD57Zc3Fm67GZbYe97d0X4+/des77+lJuJts1s89/1+6emR1dYmP0hb7kWUbdYbk9u7e3+HyneGPw7b5Ls/7b/e3e4o/0ZxRHimvz3r49b/wLyccbD9++s+s9N7/wSvd70hHs6JIb7wTG7dId8dvpudgtdu4be/HowLyyCVeeXbiy413TL5w5XBjdcUxs7Op5z9w/1C7l0TMjZ570vNvT74p/8+IfYc/Im7sL7Z4temZu6vFIcvnB6TK/nesd+4ZfzvXui/uLXNcptd01tPPIqPvylYWdl9/rONEl/6mv3Qxuvzd28pfiR3e3NDl4Yveyqi5CKgdx00hDKcQNACx/X5MxjYySOJ7CTmdL/p6wU/UMTryDrWGqVCUQNwRxg7hB3CBuEDeIG8QNIetI3Kj7wMHIwSyNkZoj55gHxI/3Rx1NjtMkd4ZaRN9MTjS7xBYMrMeHIyVvlzcu8r6VG+HZva+xtwAA1B/RR2UcXXFjuO9SNp1qcksVanPKi5vC3pZaym0QNwRxg7hB3CBuEDeIG8QNIetJ3OgBg2c9guFEcCtYDDASow7b8b5hUTeT/YkAurBFNOLbEyVuvBaUWFlMC9FBUfx4Yzjki6HwVb+RvBO2QMUNAKxMZZ+hYzzXHMqaZH2N12XF+6WkuOnc2uwvalNoa2lpGxJfm5u3diJuCEHcIG4QN4gbxE1ZJzL2yuN//+DH+l/6bl0My7GWr3Vs/ifEDUHcrIK4MYcQ5nwob5iRTquRhnrJeryx07MnUe0SEoob8yxquFJTC/bLDo9XExAWIrU24hTig+hhEuIGAJaX0DVrcROpsomLm0jfVV7cqGdISXHDU6UIQdwgbhA3iBvEzcpW3Hzrz9KIG4K4WT1xY6KkRnQt4YijSRxv3EwONYoxHyp4KWwwMmgJNUpNLcSmSsWOV9OgQsIVQI0JU4gbAFhmPFmsSherVtzomsFq4sYrsWnZW1DixivAaWkrIG4IQdwgbhA3iBvETdWKmx/83Z+IDfH/Fv/X//H+vY985X//X/4HkY7N/yRe+otP/t4ffPjfiZf++IEPi+PFHnGM+FYdIPaL7Qf/42/Kt5v1O6JZOfISG4gbgrhZXnGT1CLBHWPXsRbX1KRRIk0psVKp4qZ6C9XFjeWpVd5KE24wYQpxAwDLX24TVcjxfs+ovtHzRmsQN3NzQ20twVQpf5Gb8tYGcUMQN4gbxA3iBnGDuLGIG6lapKARGyLipT/48L+TdTTigL2PfEV8lRZG7PyLT/7exa2OOF7KmljFjTxANKXei7ghiJsVWOPGH2+Eyw+rpWd08Ut8jRt9fFKjREcpNa1xU72FKqrINhwKn9sSuQeOuAGAFcBccjj5VCn7DKlK4oanShGCuEHcIG4QN4ibJYsbKVakrxEb4lspbsQBUr7IPcrOyFqbzqe/pQ6IiRtxvHmraslFN4gbgriptbA/Mk8qojbCeUbywVKxp0oZj3+yahTrVKmFck+VqtqCMempTIWOeqpUsgYnOqMKdwMAKylujH4vNhXULMxB3BCCuEHcIG4QN4ibFRY3VStuyokbs+KGNW4I4mbZxQ0AADQYiBtCEDeIG8QN4gZxsxLiRq1xI+dSJde4UeJGbMidyTVuBKJB6X2UAxLvEo1XXc8YcUMQNwAAgLghBHGDuEHcIG4QNzxVyhLTy6xWEDcEcQMAAIgbQhA3iBvEDeIGcYO4QdwQgrgBAIDlEzedrc3laO1E3BDEDeIGcYO4QdwgbtZoEDcEcQMAAOtF3FgETbn9iBuCuEHcIG4QN4gbxA3ihhDEDQAAIG4IQdwgbhA3iBvEDeIGcUMQN4gbAADEDeKGEMQN4gZxg7hB3CBuCEHcAABAQ4qbQltLc2tHwtB0tDa3tBUQNwRxg7hB3CBuEDeIG8QNIYgbAABYPXHjO5rm5pa92tIU9rZ4SxN38FQpgrhB3CBuEDeIG8QN4oYQxE3RTaec3H01UXKbUk6+sYZGpWw61eSW7C/mnFTaLTJ+BIDFdyySTK7iTq9X9LF0NWUeBx57tpR18hTihiBuGlXcjJx+Ihh3dTy1b/SFoROPVrmS2evi4OnB9vHBfZMjJ19reLoL205edW6cvnP12QWVscsHpa66NTusjuwYaClMnhIbJ0ff2j/4ztHxV/pb73hjXWueeXf/2FR7e38VH/FitxgPT7fOTW+em3pq7vhk5yvXDx28ccwbNud/PLPvLXnqs5Mz2ws3VI6MT8/dvSmvcAlpH7h3/NqTYvxfuvuaGMyL9sUw/uDld8SnEz+KwmR3tuc9MboWOTX61q3L88W2+Zpk2fjl8e5s/N/PyAHz1IXereJrf+d3lnDZ17o2i699Hc6l9uesB0jJOJj/gfx26OJz/s5N3nu7n1aHXWr/UeyNfece9Y/83kDuicLFVtnIYP5JsdF7YnvyLJfaDwUfxz9FX+ez4betV88eUWfvO6c/pjzSP3ib2jlw4bFY40MXn5cbRy/ebO88Jja6LjwsflNXx/YX2h8tnegYOvp4f+f3LgztEUO1jo63PQXTtXDk6tu7ewcP9u2RRubktdPiLQf7du24eEv8Q3K73u3ufObYubOmtTnXcVz+XY91Pit/U+Jf7NST701tWhgb/9m5s/vE6XZc+pn8Z6BydPDeiSubxD+SZE4PDotmu8/eu7njRTPnOs+p7UL39o7ezKG+rDhy/5k7sSOrZvDCAfFxGiTd50dFRzF+5hfyp3d95qJ0aoSsShA3jTu+QtwAQH17y6BX8bxMOutv5p3QzuiduUwocbxX4x1sGXFTK4gbgrhB3CBuEDeIG8QN4oaQdSRuPCkjkSMHszRGygvx1Tggfrw/6mhynNit43z4pmSzS2yhCmIUFIyR1Ll83+QGN7oNCxO0nHYyStyoW98pf0/8Trg3xJLfe6cwPosx4gouwPss6XTQjnGb3WgqnXUd8957letMKbvkvbcpHV4GADS8Gvb/xtVG2N0FnUzwh+z1AHFNjLghBHGDuEHcIG4QN4gbQhA3Ss0EDsJzE4EgEDs9GSEGG4ZqkXrCdrzvF/ydvu/wxie6XEU0EpUdXgv6hvMiWliauEnpgZM8l79Tn8vfqW996w8YuYDYe9UleRtNTngj3T9e31qPax15Ct8ByQPCc5W9Tn2LXr+3bIkQADSWt1FqJi5uwg7W6ABrqLjpCKZJ+cvclHvIFOKGIG4QN4gbxA3iBnGzSHHzyM6v/+1jX6iLiNk5sOVrP/xrxA1B3NR5ZGEOGMz5ULJsRDkC9ZL1eGNnOD5JzjOKVMEYLSjZUbWFpYkb1UjYYHC727z1bbtOfQHGjfFIWY00Pk4u73h71PwI2xjMHLkZkijcabvOyDQufbrIqhkA0KAE5XJGjxop3zO6u5TdxtoeB+4rm6G2luaWtiF/ZWLb86QQNwRxg7hB3CBuEDeIm1WruNl8/NE/+/qDiBuCuFme0UUqNp0nvpZwxNEkjjf0h76xrOZDGXORvAYjXsMiU8q3sMSpUrFzWYWIMXsrlUpZxE2EwCuJlnOOeLt4r9gjmlLLVegLjr43FDdKAxnixnadEbwDzPcCwFrQN0bNnfxLzixtqpQusencWr3oBnFDEDeIG8QN4gZxg7hZXMXNiz1PffLzv//hj/+G+F8Q8e2Df/OHYkN8FQeobwXiYLlHfqsO+A8f+z//xfv+xw9/LHg74oYgbuo8rrBpEX8qkOtYi2uSx1u1S7zSpFrFTfUWahc35hSkcDhkO5dlsYkyFTfJ52HlMmk37ysbX9+4GWPVG/OzJD6XWTUTbNuu0/qpETcAawmbkbHV2UXK+spNlfJKbLZ2BnOmxIZXeoO4IQRxg7hB3CBuEDf1Ezcf/vhvbD7+qNj4t7/1r8VOsfHAg78jvkpxIwtqPvn533/8YEYcKfaLPWK/fLuUNVTcEMTNcq9x45d4hMsPq1k/xuq5uXLHJ7WLYWdqXeOmegvVxU18xRy/jkavMaFX8ImtcRN7+Ev5NW6Mi/dXt0mHH8Rb6Sa3UEHc+As86zVuoj9M63Ua4zr10RA3AGugyibZA+idkf7HqLiJ22HrVKkYft0N4oYQxA3iBnGDuEHc1EncPPg3f7hzYIvyNWJb7JHiRhbayD3f3f1Pys5IZaMOQNwQxM3yP1VKrZirbxGHpkA+WCr2VCljCd5EXYme6RObKrVQ7qlSVVuoqi3Cp19lXLO6x8kkHk0VTvhysubCNMFspvAscpZT/KlSugrGECu2R8ZELynlLYWj5UvGSetnVFW/zviDqwCggTHmOeo/5+iT6WL9g+XvuoanSjFVihDEDeIGcYO4QdyslLipWnGDuCGIm+UVN+t8noLTaGv5WuRLQ14nAKwiCXFTaGtptmNbohhxQxA3iBvEDeIGcYO4qbO4Ef9r8j//q/9p8/FHrWvcKHEjjpE2R76kNuROxA1B3GygmQhJrIvgIG4AYJ2Im2R9TbhnqIC4IYgbxA3iBnGDuEHcLONTpZSXqXsQNwRxAwAA60XcLA7EDUHcIG4QN4gbxA3iBnFDCOIGAAAQN4QgbhA3iBvEDeJmvYub5QvihiBuAABg/YibjlbjYVKVViZG3BDEDeIGcYO4QdwgbhA3hCBuAABgJcWN9zhwT9kMtbU0t7QNzRX2tliXJUbcEMQN4gZxg7hB3CBuEDeEIG4AAGDlxU1QYtO5tXrRDeKGIG4QN4gbxA3iBnGDuCEEcQMAACsmbvwSm62dwZwpseGV3iBuCEHcIG4QN4gbxA3ihhDEDQAANETFTRy/7gZxQwjiBnGDuEHcIG4QN4QgbsqRd1IeafeAk2pyS9Zjim465eTMjcakwuU1+JUDQINRyqZTkkzQc+QyqShBlxLuT7vF6hU3PFWKkDUvbvJt78qRXlvvuwMXWq52ZKq+pWe2r3vm6mtrjWLb/OxJz1CM35l65fohmeu3Jyu85dTl7uxobzJHJ3rFe8XPYXf/u68W7tV+DdfHT+cvPnp7+idiTDgy8bOD196W+++OTxb3bSnu2yzSNbTnwMjTk7dHp+7cNW1OjTk1MSManJ/3ZM2hK0H7uWu/uDT6pnkl01s8lyQ2hqZ+3j5wb8k/1ZvXLwbiz8+N3l1yY+RUi7m/loyde158HT61aeT049YDRjueLrR/Z+z88/Lb8a6XvROd/oH4ej33gm7nwtbYG0Wb4o0jZ34w2vGMfNfYhdaxzh/6b38ieZbxbjc4Rf7FQvujI2eeDL7t3j6efyk8+0vmZ/T2t3/Xa/Ds5sgFRxuXZxfpGnl5X/8pqUt2XvpJb+6JHaOXRo68Nbj7xPDJH7w6fK/r4iGle3oKL+/vPyyO3HV59kJ3c++1o9mr80cGnhN7Tl+6lj+5U/yujw1uutLptA9uauudaOvtPVl4ZuTyi75Ke2Gsf3fstzZ84N7VLQvZroVdPe+J9x6++rbsBKYeWyicaDl8Pbt77LL8p942Uth38vXicx0zB4ri1c7Ot3e3e+qz0Pb2/mPvZc8uHLpxesg9IzXlzAtH+ncF/uj05Z/UrmyuHp07+9LCpfPzbmFsCf/mlyNHBt48v/3nMycCpzlSnMIdEMRN3Qcn6WypDmakwUHcAMCieoxAZJfcplSik9Q7Pb8jj/QkeLyTQdwQgrhB3CBuEDeIG8QNIYgbRc6J3gT2VUV0jxhXNDlOk745HLmlnFcVN2FTGceR95AD6xE9hb19182EO8MDwjGPN9RJRfZUKwVqSnst6EGRjy4LKnedyXPVcuXGuQAAzNKbTC7ROwV9RS6jOjSvn3HyiBtCEDeIG8QN4gZxg7hBHxDEjW1k4TYFA4ZwjOENIeRwwivjN9yHf5jvNfyhiB6ThEMR73j1UkyIaDOihyhl25dHhnehjcGPeG8NxS/eG8OpB9555ba+8grXaTlX9Su3THMAALxNouJG97fJ7ZiVRtwQgrhB3CBuEDeImxUSN8/mL33qr//uhStDdXExX9v6kmgQcUMQN8s7D8jco6yHUcmv1EZC3OQcrTByTjlxY04KsO3Ud6EtMqU2YleramFquE7LuWq+cgAAoxdKxTuHvBOr+0PcEIK4QdwgbhA3iJt1VXHzwpWhT/313yFuCOJmGUYXiaGF3hN6DWO8UVbc6NqWquLGJN5+UtwsGEt7xmYTlJ8qZVxtbE3QyteZPFfNVw4AUKGDNeZGUXFDCOIGcYO4Qdwgbhqs4uYHZ3If+9wXPvjRT4j/BfnS9x4Xe8SG+CoOUN8K/nt2t9wjv1UHfPD3P/7P3/f+B7/6j2LnR/7ov9RYv4O4IYibOlfcVBU3tVfcJE1HNXGzEBNJixI38WqditeZPKzmKwcASHSwid7G4nFY44YQxA3iBnGDuEHcNIC4+eBHP/H9V0+Kb3/9w7/937O7xcZH/ui/iK9S3Igjxasf+9wXHtl/RBwpy2rEfnGkOECEihuCuFm2NW70gCGcVVRmjZvq4mbRa9z4h8WdSFLcRIc3ta1xo2SKMXBSH6fCdVrOVfOVAwDEe8tIXxTpvniqFCGIG8QN4gZxg7hpLHEjV7pRvkZZmC9973FZaCP3PPTK3s/+wzfle6WyiR2AuCGIm+W5J1zLU6Wqixv1DKZ01k1UssiXYs9mCu8/V6m4UY92SkxfqipuIlOczClgla/TnJZV65UDACxEZmga3ZStrwgnZloKCRE3hCBuEDeIG8QN4qaBxE3VihvEDUHcLPPjwJd9ZQeuEwBgUSBuCEHcIG4QN4gbxE1jiRvxvyb//H3v//6rJ61r3ChxI9776x/+7Yde2fuxz31BfCv2y2Ok4kHcEMTNqt9m9p/kXfYG8nLWChlUr39Z8esEAEDcEIK4QdwgbhA3iJs1+lQp5WXqHsQNQdwAAADihhDEDeIGcYO4QdwgbhA3hCBuAAAAcUMI4gZxg7hB3CBu1qO4Wb4gbgjiBgAAEDeEIG4QN4gbxA3iBnGDuCEEcQMAAIgbQhA3iBvEDeIGcYO4QdwQxA3iBgAAcYO4IQRxg7hB3CBuEDeIG0IQNwAAgLghBHGDuEHcIG4QN4gbxA1B3CBuAAAAcUMI4gZxg7hB3CBuEDfoA4K4sZBzUmm3KDZKblPKyTdUawAAa49SNp2SZHK6c8ykFOlsKdJvZiJHIm4IWbfi5u7tohjdDeQeF1+HTz12uzj8GoTc6hmTI9JYptrPX+t6emltDrz07sieH9/c+0ps/9iFF8Q4/3ruR7Oj+Zmj2+ZmPKM0s/uiPOPsgXNS66gMnTsT2yPTPvBa3/TPPUk0+9MjVwNxU+o9davvgnm609fe2tn93v3/iK5fnTow8rTKuakzu0cOiMu4fPKEtBK15/DQj8X45MaW2Yudz1/obk7m2Pju0zt/Uejukzrj4kj2zJnsROvNqcfnitn54jMDgwdeOHnVOT5xRok5mbbxo7Pb983uOny+63hP4YB473S2NJb1vNiukcnYiP3E9e0jr96aesyzGDN75g9f23Js+CX57Vjnmd5LHdmzCyJj588U23bI/SLFnW+8cs5zoPu737n67IJM8cCrsX85N4+eu549Ij7s1ek3xNcjQ293Tby5s/f1wsnHxN/gxIHnpi4dH7jQcnzk3qWuV8+f3SOO2XHpZ5fPOmIje/U9z/JcefPK2YzY2O7n2HAg3a7N/Ez+GK/4LR+49o7UT+Pd22dGzsd+a9PXzw31bDlz4d6h9nvip9Hbezjb9Qvxo5t64Z74LLk97568/B3x7em+R6+cfVh8qB1d713IvSF+zp2db0ovc3nPO3vO3bp0bW72xPbIP8v274zt3VI8dESe6PL4G+LgGzd/WvUf0mTp9YOX3+kceFKctxEyPtNjXt7snQncAUHcVFQtDdgaAMBao+imm1xfzHj+OnQ05V123okpHsQNIYgbxA3iBnGDuEHcEIK40TeGxVhC3gB2i+G4Qow6Uo4b3DEW+3NO7Naxd4DEyS1jawAAa7/0Jujrykltsd9xqLghBHEDiBvEDeIGcYO4IYibGmpkTNUS3CX2a/v9V72d8jDPvMj7xt6rwY3lZWoNAGANextdcaMNdaSjE/2eOICpUoQgbgBxg7hB3KymuNl79ut/+uXfPdr9rbq4mO/+8E9Fg4gbgrhZfnET3Bm23C72qvrD0hi/mia3jK0BAKxN5AQo1afpvs6vTJQ9YTipCnFDCOIGEDeIG8TNOqm4Odr9rT/98u8ibgjiZkXETTDYKKNaTGLF//VtDQBgreubhI8OdopOMujxEDeEIG4AcYO4QdysfsXNvs5viK8f//QHxP+CiI1/fMRbBkN8e7T7W2Jb7JEjtie2/TfxFvmqPFJ++zsP/Nqvvu9XvvB3/1m9C3FDEDerKW4qTWiqb2sAAGsZo+QwIm5Ev2dOnko8ggpxQwjiBnGDuEHcIG5WQdx8/NMfeGLbfzva/S2x8Y+PNImN/+dPfmvb/r+V4kYcKbbFnud2/b//9wO/LstqxH7xFnGACBU3BHHTKOLGWJXGf+RtLVOlltwaAMAarLIJfbTXrfnbRu9nPmoq7DepuCEEcQOIG8QN4qZBKm7EtvI14qUv/f1HpbiRhTbSyzz10hfFfvleqWxiByBuCOKm3oMM+Sio+HOgyqsWc5VNc4+xfMN9tgYAsJYpZVUxjZbR/ursKeuTvxE3hCBuAHGDuEHcNLq4qVpxg7ghiJvlFDcAANBwIG4IQdwgbhA3iBvETWOJG/G/Jr/6vl+R+5Nr3Chx8/FPf+Dff+h/e+qlL4pGxLdivzxGKh7EDUHcAAAA4gZxQxA3iBvEDeIGcYO4qedTpZSXqXsQNwRxAwAAiBtCEDeIG8QN4gZxg7hB3BCCuAEAAMQNIYgbxA3iBnGDuFmP4mb5grghiBsAAEDcEIK4QdwgbhA3iBvEDeKGEMQNAAAsq7jpbG0uR2sn4oYgbhA3iBvEDeIGcYO4IQRxAwAAVNwQgrhB3CBuEDeIG8QN4oYgbhA3AACIG8QNIYgbxA3iBnGDuEHcEIK4AQCAtSFurFOlLJOkEDcEcYO4QdwgbhA3iBvEDSHrS9wU3XTKyRk7cplUOlsKvyu5TSmftFus52n1WRIXsNgLBgBoKErZtOw3U5lcoi9NpZrcktETlutgq1bcdG5tbtlboOKGkLUkbuZuF8XobvTsZvH1wHD3+O0SvkZbreuTYrCqsmt4ItfTP/vinuU4lxjD9+1851Tu7f7xN9TOKwNvHul+Rwx9952ej2kOMWK36g8xgF/hn1LfuUcL7d8ZPrXpWvu3pVLp6/Q2Bk454h9V7RnpeUG+3ZpcYdeJKz+42vGw2B7q2SK+Duaf1OfKPS42+jofye8/f+l4Z6zl0e5tZlP957/Xf/7717qfFsfHzjKY/8Gl9i0d7i8Cm9a3S5xxMP/UwKmHh09u8t577jviY04ePjb2yg7x7ezxk8Ovfk+cYnbvkWsnHhUbY+ef77+wSZ63r8ORSlScqKsr03Np0/RYpzzRxPDx2I9x5OxTI2c3z072es1O9qr9xzve2dmxcLwQCJq5u7dEy6/Nzyd/EYXZn73S58m48dJPD157u3Pq2N6xbRNnztzqvhw7cnb0wvXctuIr89Nb5tqOLmRHL409e1v8Cx/teO5s/0/Ev7eLp34kzjJ06kmxne1a6Oj54c3SyOzUZXFt17o2X832X95/t+36Ve96SjMzR7eqlid6dx/r6Om4emtp/5aOny9mR3tXPa9OdL5y/dD4Hd3ljpZ+vFgRSUgds1YqbuQoQokb71s58Mg7qbrqEsQNAKxPRB8VqBlP1siOrpRNh/1qZGcgcWwdbA1TpTpbqbghBHGDuEHcIG4QN4gbQta/uNEexL8hnMkZFTd6gOEf5t8T9o93grvEKSefaNAbgfgvZRx9YzncKfeo29Hp7KHwBf8avMaNb/0LCE+Rc7wLyEWOBwBo8NKbTM6y0+8Jjc7W69li3Wl1cdPRylQpQhA3iBvEDeIGcYO4IWRDiZtELYz1hrDvVuQBXj2OUfMfHX74Gki+qqRP6IbKVNzooYvRstjpvSquJBjVUHEDAGvE22j3HSts9LpBU0xbjqxljZvWDhYnJgRxg7hB3CBuEDf3LW6+vOnhb+3YWhcXs6Xn1Ne2PY24IYiblRQ3C6o6RgkabWF8mxMTN/lolY2qr0nstIgbc7KAeVXeW9LpyAUgbgCgsQnKDBOdle7ozCqbWsQNT5UiBHGDuEHcIG4QNw1fcfOtHVu/vOlhxA1B3KyguCk7VSq3YBc3Vkej1+k0ZjmVETcmarVO87404gYA1pa+Mfor71trz4a4IQRxg7hB3CBuEDerXXEj8vHP/9d/8a/+pYjY/vXf+pD4fxGxsaXnlNj/oY/9J/Ht734mva3/gojYkIM2cYD4Vhzwax/+4G/94cf/9W/+htyJuCGImxUSN2ZxjRpXVBQ3ZStuEqs82MVNfOJVIIPSWdexFuMAADQyRi/qK+xylrzyGjfWB4HzOHBCEDeIG8QN4gZxU29xI72MtDZbek6JjU//zV+IjQ997D9tOtYmjhTfypoasSEnRom3bD539OOf/6/yACpuCOJmtStu/HFFZXFTZY0bvXhN5TVu9AhHPZ9FnEvaH8QNADR4lU3YMVZ+btRinypV2NvSvFWJmkJbC2vcEIK4QdwgbhA3iJu6ihvpXKSvERubjrX98T9+ZUvPKfHttv4LysuoNXFkrc2jB3ZIv4O4IYibVVrjRj3Fyfb0bjU+ie2UE52ytqdKhYfJ+VN+m/IUsadKSdEjnyQVuzDjeACAxsOYHxr0VLlMdCZo2DeG+3VHV17cJB/+zePACUHcIG4QN4gbxM2KiJuqFTeIG4K4WV5xs2yET04BAIBFkxA3XolNc0tbwf4t4oYgbhA3iBvEDeIGcbNs4katcSP3J9e4McWN2CnNjqzKkRuyNkfaH8QNQdysMrpkJmVdsAYAAJYkbkJZoyhvbRA3BHGDuEHcIG4QN4ibRYibqk/4VlOl6hvEDUHcAADA+hI3PFWKEMQN4gZxg7hB3CBuCEHcAAAA4oYQxA3iBnGDuEHcIG6WO4gbgrgBAIB1JW46WnkcOCGIG8QN4gZxg7hB3BCCuAEAgAYUN52tzZWe/424IYgbxA3iBnGDuEHcIG4IQdwAAMAqipuy9TWIG4K4QdwgbhA3iBvEDeKGEMQNAACsorjxp0pt7UTcEIK4QdwgbhA3iBvEDSGIGwAAaMCKm2bWuCEEcYO4QdwgbhA3iBtCEDdlKLrplJO7ryZKblPKyTfmEMm7No/M0j9iKZsO3p53Uk1uiXEnwEYll0mF6G7T6yJS8X5GHZnOlqpX3MSpNHkKcUMQN40obl6bf00M2Ea2F8UY79JMHlkT43Z/vrhvs8jczWJxx72ZY79YphPNjFwQQ+U9Q8P7RuO/6PaBe2L8PFl6vTF/RO1Dj08eemZP/s0DHbNTB54Un6J46JmBU9++0PXwyatO7ekfP1ho/045rTN5rGfqqSn5uxjveqlj5Hj35cNie+bgs2NHv3/96KZJeeqjrTcuuMcGv2vm8oArjpze/5Q4YGb/08fOTx+7MDJ2YevwqU3XDz9mnuXqhX27z/1k8sDzgYa4vFdc0ljnD6/v+VFxW2duzL10YdPB/h3nOmcu7xj0riS/fd/oITHIf/XsvdHnpqYeW5j+0dsjZ58Se0Sm+o6cb9/X3j23d/zY6YubBy48Njua9y5y3+bSlc7Yj/HG0NHxwYPzr82LN/bODtTrtzM5cmr82sEKB/SMvdm+583pJ+6IqxLfdhXPiq7gyMQpcRlt40fH+vdI0zTW33aj9PqBa++MHn3rwo8W2k+9U67Bid7ds2Pd92sDZy+Kyzg4emJRg9vd/e/KjdNjby3tvOM3fyr+1mY6hkvnhyOqa3JkUf+YCalvEDcNPs5y7vvTaXEDABuZvKO6As/LKJ+bSrvFQBNLTeN1GoHkFV2QfLWCuCm0tTTbaWkrIG4I4gZxg7hB3CBuEDeIG0LWs7jxpIx5c9gsjZHDCfHVOCB+vKwxcZym4M5xMPzIO6lyzS6xBdOzBMcYIx/Zvj8oavKa98+lrjwcPvkGyg1ufctG1DFpt8fwU6pwxnptxv1zbwymLlWcxai4id9O98/uhDsbtf4IAOoncfwuJSJ2gy5CdFZxWVNtqlSsvibcM1RA3BDEDeIGcYO4QdwgbhA3hKxjceNpC2kQPMugb/8Ggw1DtUijYTve1xb+Tn/OkTc+ibgVX1soceO1IEXGIluIzEQIryGdblIXJjbU2yN3tv3r91uTzsg/wHK7u1hG3MSvzZwPFbw3OVXKNztadXkt+Bvxzw4A6xTVycTFjdczeF2Wa/rfRU+VYnFiQhA3iBvEDeIGcYO4IWQjiJvwhnB8PpRnH9JpZRbUS9bjjZ3h+CRZ+R+KG/MsyqfU1EJyXlLJzbg5aZeC6QmGrLEW6agzRip3qoqb2LV52iV2lqS4MY8JZkyYZ2cpHID1TezvPdz2C/GkuDErAatOlULcEIK4QdwgbhA3iBvEDSEbV9yYqMFDdC3hiKNJHG84CO0v1HyoyFSmqPpRxqSmFqIjIrFTfPWnJqWzpURdT/LTJdRM7eImfm0WPZQQN5Fjglet7QPA+rQ2kemQauKkk5F/+6abtnQpiBtCEDeIG8QN4gZxg7ghBHFTSR/4HsR1rMU1yeOt2iVZHVO54qZ6C7H6HSfnKxuvkYwbrhYRW6AntlhP9M623raIGz2RynZt91Fxg7gBWO8Y9TWVCgZ1Z4W4IQRxA4gbxA3iBnGDuCGIm7JouxFZk0U5C2NN31y545NqI2pAalrjpnoL0ev2VrcJl57JqFlddnHjX6pe46bsI130TXJ/OZvy4ib6Xu8tNa9xg7gB2DAzpCx2O9ovxZ85hbghBHGDuEHcIG4QN4gbQhA3ZUr6o09Z0kOIsGxEPnop9lQpy3ItEbVhnSq1UO6pUlVbiNa5GFOujP2RqVLGg59yZr1P+Fyn5Jwp9Za0m60wVSoy8SE4tZyWVcNTpRA3AOsY3XFFe7l4bxCbP5V4xpztqVLliD1tCnFDEDeIG8QN4gZxg7hB3BCyzsTNhrsZHnu4OABAw1HD48CpuCEEcYO4QdwgbhA3iBtCEDeIGwAAxA0hiBvEDeIGcYO4QdwgbgjiBnEDAACIG0IQN4gbxA3iBnGDuCEEcQMAAIgbQhA3iBvEDeIGcYO4QdwQgrgBAADEDSGIG8QN4gZxg7hB3CBuCOIGAADWtbjhceCEIG4QN4gbxA3iBnFDCOIGAAAaVtx0BA8Eb9lbqFqAg7ghiBvEDeIGcYO4QdwgbghB3AAAwIqJm85WqWyG2lqaW9qG5gp7vf8WEDeEIG4QN4gbxA3iBnFDCOIGAAAaQNwEJTadW6sX3SBuCOIGcYO4QdwgbhA3iBtC1ou4KbrplJNbgVGI5UQltynl5Ot/qlI2nWpyS6v7eQFgo5LLpEJ0b+P1S5JMLnlkOluqJm78EputncGcKbHhld4gbghZW+IGKnutOU9szeyb94bWMz892vP28p2rd6Z0cuzO/kvxIfHQ1M8aWdyMD+6XY3uRvnOPyp35i49e63pK7a+aa11PextTPzs5+tb0tZNJcTPVf1RLrmO/mD3zZvALmp8/X8iOzfZG/l5uT4vWpkbP6LdMvN516Oe5nkzs4k+cu1bct3n2yJ7icx0iM7t7zFevD7QdGDt6dOLM7dK4aLDQ+4LYOX39vNgeyD0xesXtGdnbNXbQ9xp7Rru3edfZ6UmiyWvHxc67d2bM1goXW2cmem9dPXfr0pnkj3F64Nhk3+GV//XNzfxkatPCdPZeoF2GT4grnxw5Kbavdjw83rtzsu/IUM+zpZmC/mHuny/unF/eqyp6f3e3h8Jv525d6G5WuXT1GbV9dcD7pdy88xPxNzI281NPts79+JXu95Z86j3Xr0zeuZW8ngs7StsLNwhZlVBxs5LGBHEDAKtG3lFqxvMyclvsTKXdYiCspaYxeqqcE7xaueImjl93g7ghBHGDuEHcIG4QN4gbQta3uFEiQ4wrmhynKbj7GwwhvMGGed/Yr5HJuunYLeKim07cXtY7vZFJzkkeYFTc6BvUcpDjX5Ub3KAWFxO+Xd2ptp4xuNq0k5HDIbOiJxwXmeJGfbpylgcA4D4ljt/heI5GdV9eZys7qLisqVxxk4CpUoQgbhA3iBvEDeIGcUPIRhM3Kak5PN/hjzH0TWAx6vA1jf+SPN57o3zVsyravyRuIIud3nsrTJUKhjFyj9IrgRjynY7aqc+oX5Xv9d+ir7+quNGtqc8LALAs1X9xceP1QqJTUnq6lqlShbaWZju2JYoRNwRxg7hB3CBuEDeIG8QNIetS3ARiJRxjJKv3dZG/NjLGG6P1O9EylprEjXmwdkbhgMdWNaOONBvRN7TLipvIdKrkBQAA1KF3NasXtcsOxY1ZY1jLVKlYfU24Z6iAuCGIG8QN4gZxg7hB3CBuCNkgU6UCeaFdSWS600JsOWFD3Jh4ww/LKjMVFycuxW47GwdbxI2pisKdNhFTTdxEYOEbAKhv1xpZfF1NCHUyTjiBVMmaiBOveapUJRA3BHGDuEHcIG4QN4gbxA0hG0PcmAX/3h5zdBFuW8tVFlVxk9xTWdwsoeJGHWaKG6ZHAcByYNTX2OdPhd1p2AEibghB3ADiBnGDuEHcIG4I4mYJ4iZqT/QaN3pNmfgaN34ZS2wFmfC5KuXFjeFQzDVuyosb6xo3+jIia9zI9/oXVm6NG7MRAID6zZCyuOxohxl/5lQVceM9ETyktQNxQwjiBnGDuEHcIG4QN4Rs+IobPZ/InCqVCeZG6WIZ/YwnY+wRf2aTfDKUXNlBrwqsVUvtU6UWKj9Vyn/ulbFisd+sW+mpUsyTAoA6UW4appoqZVbW6PlT+Xg7SXHTudXTNZ3eKsUtbUP+WsVbOxE3hCBuEDeIG8QN4gZxQ8h6FzeLHJIkJjcBAED9Kb84sRQ3PA6cEMQN4gZxg7hB3CBuCEHcIG4AABpF3HglNi17C0rceAU4tgeBI24I4gZxg7hB3CBuEDeIG0I2srgBAIBVETdzc0NtLcFUKX+Rm/LWBnFDEDeIG8QN4gZxg7hB3BCCuAEAgJUVNzxVihDEDeIGcYO4QdwgbghB3AAAAOKGEMQN4gZxg7hB3CBuEDcEcYO4AQCA2sVNZ2tzEhYnJgRxg7hB3CBuEDeIG0IQNwAA0HgVN51b5VrFiBtCEDeIG8QN4gZxg7ghBHEDAAANJm54HDghiBvEDeIGcYO4QdwQgrgBAIBGFTcdrUyVIgRxg7hB3CBuEDeIG0IQNyFFN51ycvfVRMltSjn5Ol1P3kk1uaWlXUc2veT3AgBUJZdJhQTdprHHvj+dLVUTN5Y1blo7WJyYEMQNLInb1+anN8+tucsu9bQX920OcvBZtX/s3JakfymXsfPPi6+3Zob6z39/dvKyb0m2Xml/Wh3Q1/nI9PVzsuWbxQFxwPzcLSluhgfaxbd3buk/EDmMvzz+RuxSB3KP35odMffcmh32tFH3D692ZAZPOucu5k6OvmUecHO6XxxwvfvY1ONzxR2erZgdzYnrGTn71M1zBycv7h3ufn7kzJNi/+ThS57jO9hzs3Pv7YFu8dOYv3UzooFyP7o5fqkBf4NTT79b3BmIm+nxnC9u2r3tJ+fujvu/ygutt6eHV/ciD115Z9eVvjPb3z370sKxi2/vOr0w9ZiX3KWe7mKnOODYxLX+0rTYuDs/nx3tnX+tnmpp/uatGdfV/84JWdkgbuoM4gYAGhPRO2Vy2uBkckmFLTWN0RflnFTaLS6y4oanShGCuAHEDeIGcYO4IWSjiBtPypg3gc3SGDmcEF+NA+LHS43iOE3BneNg+JF3UuWaXWILVnHjNRsclDdeTZXbmXYyiBsAWCmJE+u+In1XXNZUFTeFvS21lNsgbgjiBnEDiBvEDeIGcUPIehI3npSRdsO7Oaxv/3qDjVI2bagWOfywHe87EX+nr1G8O8z6BrJoxL+9rMSN14K84bzIFiyDn2gL/vHepeo3Bq/6qki3j7gBgOUnUd8X0+KOm03XPFXKe4yUXtRmqK2lmadKEYK4AcQN4gZxg7ghZCOIG/OGsDkfyjMj6bQacqiXrMcbO72BSlS7xEcs5lmUZKmphaS4MUdBegKC5ea2ObXqPqZZAQAsppgx2olFOh+/klFOpEoeaV/jJrYUMU+VIgRxA4gbxA3iBnFDyEYRNyZq8BBdSzjiaBLHG6ORULsY86GMOU1eg5G5A6GdqamF5PhHl//I+h1dyKPw3xu57424AYCVsDbx5dhVHxXp/cp454S4KbS1REtsOlqbW9oKiBtCEDeAuEHcIG4QN4Ssf3Fjsxj+7CTXsRbXlNUoUe1iThbw9lSruKneQm0VN6YYouIGAFYeNXMz6m2iVYRVCgZta9x4D5YK3I03VaqlbYg1bghB3ADiBnGDuEHcELKR1rjx/Ihaflj5Dl38El/jRh+f1C6Gnal1jZvqLVhUkWWNGy1uzOVs1GWzxg0ArOwMqZj+Tippm+ip+lSpyJI3iBuCuEHcAOIGcYO4QdwQsjGeKiVHDpHbwmFtv3ywVOypUsbjnxL1MqVw0c34VKmFck+VqtqCMdGg0lOl1J60m4+u2iMPy7ppxA0ALA+64yrfy5mTp+LPv7OIG3MtG2/CVED5eVKIG4K4QdwA4gZxg7hB3BCyvsQNAAA0GJGKm45WbWuG5moBcUMQN4gbQNwgbhA3iBtCEDcAALAi4kYxpApuqhgcxA1B3CBuAHGDuEHcIG4IQdwAAMDKipvoQ6ZY44YQxA0gbhA3iBvEDSGIGwAAaEBxw1QpQhA3gLhB3CBuEDeEIG4AAABxQwjiBhA3iBvEDeIGcUMQN4gbAABA3BCCuAHEDeIGcYO4QdwQxA0AACBuCEHcIG4QN4gbxA3iBnFDCOIGAAAQN4QgbgBxg7hB3CBuEDcEcQMAAIgbxA1B3CBuAHGDuEHcIG4I2TDipuimU07O3Mg7qSa3tDLjlfs510peJwCAjVwmFeL3n5E9kf36+EwOcUMI4gZWjjtzP97Z/d7avf6J3t3T107qse6dOzd3vFhrjh2YOfbS7ZmxsXNbxm9ePTb43fbB6d2n35l6fE5m+NSmubu3ZMt3J4aLB7cEZ5mf77p2x80vzNz+iXkx/ee/d+d29T8ZcUZPG13Yen3f07Mv7imdzccOGL89tnds2+SdGyOXX54aPaNsztDF572N8cvjXdvlztm7M+LI6S1zNzvn1+4v8VqpT3yKyzNd3mcf3D9RONZQlzfU82zfue/c7hsqvrT35SsLRwbfFr/688O/XIFT53uz2ws3CFmVrFVxsypCBHEDAGsX0QuFFsZmZEpuUyqdLUWOTyFuCEHcAOIGcYO4QdwgbgjiphZHE1iPnKPuCVeouPH3uJnY3WP13nAc4rWQTjcFx+jbzmqU4h0QbcTesjfaCXblFyq/F3EDAI0icapIcNFnOg4VN4QgbgBxg7hB3CBuEDcEcbMYcVPbVCn/LrG8bxzeVTbuJPu+xi0GbiVQLboRcaT/qi965KteI/JVS8uxV/V79WHqVcQNADQGpWw62iN5naRWz37fJToxpkoRgrgBxA3iBnGDuEHcEMTNMomb8I3JqVWeVVHiRnqWmhux7DRHO6EeMk+qzoK4AYAGwez9rOU24gD/W8QNIYgbQNwgbhA3iBvEDUHcLI+4UXsizkWhxI12Ot79Z/maLMyJHB++xdKyLsxR96ijcxBCT4S4AYBGsTaR4hrdd+nqm0DrIG4IQdwA4gZxg7hB3CBuCOKmJnGjq/oXW3ETbJt6xay4cXKJCQRBBY3Vs1hapuIGANYOekanrQ7RMDsRou4GcUMI4gYQN4gbxA3ihhDETey2sL/67yLXuNHL03hDDi1u/MqauLjxdgYjE8saN/5bdNlOtGXWuAGANTtDKlneuBCvxKHihhDEDSBuEDeIG8QN4oYgbsoSTl9Ku1llPeTDoSxPldKl/t4ex5FPegpdiTETKhfUyETGKvrJUHq+gL7tHFkKJ3iqlLYwPFUKANYAqhtM1dw7IW4IQdwA4gZxg7hB3CBuCOJmeeYCoEgAAJYHxA0hiBtA3CBuEDeIG0IQN4gbAADEDSGIG8QN4gZxg7hB3CBuCFmX4gYAABA3hCBuAHGDuEHcIG4QNwRxg7gBAEDcIG4IQdwA4gZxg7hB3BCCuAEAAMQNIYgbxA3iBnGDuEHcIG4I4gZxAwAAiBtCEDeAuEHcIG4QN4gbgrgBAADEDSGIG8QNIG4QN4gbxA0hiBsAAEDcEIK4AcQN4gZxg7hB3BDEDQAAIG4QN4QgbgBxg7hB3CBuCEHcBOSdVJNbqnOjJbcp5eQXFopuOuXkYq9l0xXOmMukPMQB4sI80m6xplOKN6azJcaEALB8BB2UR9CzGXus+y09GOKGEMQNwOK42vHwlbMPqYiB97XuZ8RGT+5k4cQjMhNHO6eeLfV1PjJ15/b+8T7xrunr58UxA7knBtu/LQ64nts2cWmPtf35+fmh8Rtto5Ox/SOnH79bmqx6eXcnXp96bKHY9taBkad7Cq446cTwceuRs+cO3O4PtE5pcmA8/2K8qdKUuNRXr967OPbmmv6VFcfzI5dfFhtT/UeLQ6cb6tp6Zvv2F148N+xdXr545tWx7ccGv9s3uRJ2afbEy+29z/sWb/zU7h+ffWmh7unYvrB7YOyV64cIiQVxU0ncWF+rJG7EG4NxjjhsUSIGcQMAy95bZnLa4GRyyX5P9kK6l/MEdFxeI24IQdwAIG4QN4gbxA1B3Gib4URvAvslMNE9Wtx4o47gtbw6OJ1uMg6OGhnlSrxRSsq8vWyruAkraJxMuswZ9bdfy4QN+kMjdU/bVDNqp3ivugDcDQCskMSJGRlDghse2euEYxYbcUMI4gYAcYO4QdwgbgjiJi5ZPK/hGRBvCCGHE571UDeE/Y3IHulffMsTG3KETckBiX+YMYAJ70InxI1uyrcz6oyyKXVGyzUb966N69GXEZ6CihsAWDESlYOm1I5vx7omxA0hiBsAxA3iBnGDuCGImwXTaNj3+NU0gXbxhh+2kYY6xnqf2TbHKvQpCXFjHhxsmzei1dmT4iYy7AntjGUqFuIGAFaIZN8Y6Q/jnRvihhDEDQDiBnGDuEHcEMRNzZX8eo9RLxPXKKEEsS0trN5oiBI9xSmc3BQXN5G708YZTWJGxhQ3EcLSIcQNAKyStanc/1BxQwjiBgBxg7hB3CxV3Pz5p4IlMcQG4oZQcVNbxU1S3MghSs5cRVhJmUVW3CSft2IXN4l1jqm4AYDVQM/rtOhsW3fEGjeEIG4AEDeIG8RNzeLmwDNzf/6pzPHWN6m4IRtmjRs9YAjdyhLWuLGIm2CZYVPWBNt+EY1V3OiLsa1xE10Bp+waN7Hr1++NVQABAKzIDKkylnyRT5XqbG1ubtlbQNwQgrgBQNwgbqi4WfjGl7ZTcUM21lOlks+QWvRTpfSqw4YW0QJFfRu0GavfsTxVKuVk3XTijOasq/jyw8YDpIzn78avVj5YCncDAMuE8fi8cr1opOjGeNBetYqbjtbmkKoGB3FDEDeIG0DcIG4QN+tZ3Mgcb33zMx/96kvfG0bckA3wOHAAAGgsyk6V6mht3tpZ2NsSKJytnYgbQhA3AIgbxM2Gmyr1gV97wKy4EV+f+uZ55XFExEa5uVSIG4K4AQCA5RY30TKc1k7EDUHcIG4AEDeImw1YccMaNwRxAwAAjSpuCm1BzU1L2xAVNwRxg7gBQNwgbhA3iBuCuAEAgNUWN3qGVBlfg7ghiBvEDSBuEDeIG8QN4oYgbgAAYOXFTWdrDb4GcUMQN4gbQNwgbhA3iBvEDUHcAADA6lTc1A7ihiBuEDeAuEHcIG4QN4gbgrgBAADEDSGIGwDEDeIGcYO4IYgbxA0AwEYXN3KqlBWeKkUQN4gbAMQN4gZxg7ghiBsAAKDihhDEDQDiBnGDuEHcEMRNg4qbvJNqckuNNrIJrqrkNqWc/H20U3TTKSe32JcAAGzkMqkQo/fwOpPYTq/v8km7RcQNIYgbgPuj0P4dJWhExvMvXrx4YHvhxtX2galNCzJXjrx9vO+NwsnvqXfdHuq9cejxK2cfGn/+ujjg0umRc9MnyombGzdu3M8VXut6Wkql/tMPiyucvtZuPaxz6sTwrYHKTQ1dfH4g17LWf2WzY903enY05rVN3L574HrQE052vzF6/JcrdurS9df7XrhTaH9sWc8y2NNzc8eLhMSCuGnoq0LcAEAd+6VMThucYDvnpAK/XMqm5U79at5JJfqZao8Db27tQNwQgrgBQNwgbhA3iBuyUcSNN6KI3AdO3hnWikTdIg6LXLyD0+mm6L1l73jHid9MrvheX5G42XT4lvCqwiGQP7aJvj1acVPKplMG6Wyp2l1ueYz++M9lwnf5gytv2xQ36gIa0GEBQGNKHNmBGDZnweiIjG4qXnSTFDedW+VyNoW2lpa2IfG1uXlrJ+KGEMQNAOIGcYO4QdyQdS9u9Dyj8D6wJzLkcMK7ISwlRShuInvkSMM3I/GZSr7j8Hf6lkTdXq7wXn9bn1cfEN2Q1xm5quRUKfER5MH6Lrc6u7rd7b/qj6mUnYn4KXVedYxsU38iAIBK3WvYWfki2I0p8khXVr3iprM1WIRYihtzD+KGIG4QNwCIG8QN4gZxQ9axuElOBTL3KFthUSTh7WLbvWJzHBKKkmrvjakZ7VZsjVcSN1rWRIZD4ecyGk9+ZEPlyFOY71KFNo05cQwAGopYnxZuG/OnwjpBW3+SEDdeiU3L3oISN14BTktbAXFDCOIGAHGDuEHcIG7IOhc3yTu9kT2hNwlUheFE/OFHfDJR0q1EC3kqvdfYtoobY73PVHlxY8w+iM6uMidtqaaMYp/g1OIlOevKmMIQipsILHwDAJWtje7xIr446GMXPVVqbqitJZgq5S9yU97aIG4I4gZxA4gbxA3iBnGDuCFU3MSqZmoRN9XeW1ncmDqpfMVNzlikpobSmLDx2EI2GTeYJ1W5TgcAoKwQj4oYsy+SvVlE1kSNczlxw1OlCEHcACBuEDeIG8QN2ZBr3ESfdRKW1SxyjZtaxE2199YqbvwlZmzixpyAYP90fguG3EmscRO+RQ+xLGvcGB8EAKD8DCmLJtaLZMUqbuIrhdnWuEnCGjeEIG4AEDeIG8QN4oZshKdKJZ+7tOinSul5RsE4xCZuKr+32lQp9d60m4+tJSzFjW48ZT6OSn8WNZRSj5FSIyW5J/EpFhbsT5VinhQAlKHstErVF2ntq/uiWLlNLRU33qPBeaoUIYgbAMQN4gZxg7ghG+Nx4GC9MQ4AsGrUMFWKp0oRgrgBQNwgbhA3iBuCuNmIcxwst74BABA3hCBuABA3iBvEDeKGIG4QNwAAYBU34cOkktgeL4W4IYgbxA0gbhA3iBvEDeKGIG4AAGDFxE2yvibcM1RA3BDEDeIGAHGDuEHcIG4I4gYAAFZR3PA4cEIQNwCIG8QN4gZxQxA3AACAuCEEcYO4AcQN4gZxg7ghiBvEDQAALE7cdLQ2Nze3dszNDQXL3XjbiBtCEDcAiBvEDeIGcUMQNwAAsNriprO1uaVtKFilONQ3PFWKEMQNAOIGcYO4QdwQxA0AADSOuNG+hseBE4K4AUDcIG4QN4gbsiHETc5JRXDyyz8iKbrplJNjZLawUMqmUxn/J5F3Uk1uaVFvFm/hxwjQeOQyukPNRfq92M6S2yT3pN1iVXETmyHl1d207C0wVYoQxA1AwMDV9rMvLahM75ofODB0YOTp0t3pofZvF048cnh0S8fE3r6ZC7E33poaGjv//ETh1StnHyoVBwdyTyyTuLl5sP3AyTvnTu/Pn97ffune/TR15Orb+y+9wy99Zbh99fKtjtMrdrrpW6+7Xff2jm27PX9r+c7Sd26m7egCIbE0uLjRssYfWiy7u0HcIG4A1iviDzOT0wYn2NY9rfqr16/a/pZZnJgQxA0A4gZxg7hB3BDEjU3cyEGFMgj5sBzHcArqZnL4LnXTONzjeZl0uim8sZx3ouU8qsbHfzV5F9pTGOl0cFLdeDpbStofN5uO3K+OvHep12/eMDcHYNE99gFbk+tmwo8TfjR95bHrUd+KNmPvTVytbiRs1skgbgAaXuKobjDedXg9T/B37feZsaIbxA0hiBsAxA3iBnGDuCGIG7u40eUweizhqw1/1KErRMLDPLOgNYR/vFm2YwxItBLSFTfe2eXQxdKOeTrvyKikkP5CXVXivcZlVLt+fdPbf68ufhFvLLOn7CDNOKP2VjX8PGPvVa8aektpL/0TQ9wANHhJnd91iI101nWikjracVFxQwjiBgBxg7hB3CBuCOJmkeImXnoT1r9EJ1KZe8IbyLa7x5HZQBE3FA5X1LuMMYwhbqzzrdRZxKeIvzcy+SjYn7x+8+OHryZnLdU4j8k4ey5j3ksv9/OMiZv4p9aNKMEU/4khbgAalZi2DreN+VNyf8ravSBuCEHcACBuEDeIG8QNQdyUETehQQhGFClzlc3EwdE9gWiICgVjnc5UXNxE7jMb8qXSzKZEZVCZ90ZESXCw/fpNpChRn115k+SeclOlShXETfznaV/jJtxpzKRQO82fGOIGoKGtje5tIg7a8MhMlSIEcQOAuEHcIG4QNwRxs2hxY9b2WxdlqK3ixih7SZbAVK24sdx/DtWMteLG+t5aK27KT32q8nkXL24S1UMVxQ0VNwBrE3POZrnuKCJrIpYWcUMI4gYAcYO4Qdwgbgjipry4KbM8jVqARhf5h6+WWeMmKW78pVtqXOMmqT/KrHGjC2QS77WucWO/fr3HO94wLMGKNsk9SxA31p9nZXFjW+NGD/BY4wagwWdI2Ryx6o5iFTdxI4y4IQRxA4C4QdwgbhA3BHFjnyuUmDYVe85R8hlM1qdKJY9Pu/mIr6n4VClVcaMvL964v+FkKrzX+lSpStcfSqJa9ixe3Fh/nnJP+FSpUmJWRYWnSvlrnSJuABoL66RI8y/X2r8lOxbEDSGIGwDEDeIGcYO4IYibdXBbG20BAOsTxA0hiBsAxA3iBnGDuCGIG8TN/Zw6QS2PnQIAQNwQgrgBQNwgbhA3iBuCuAEAAMQN4oYgbhA3gLhB3ADiBnFDEDcAAIC4IQRxA4C4QdwgbhA3BHGDuAEAQNwgbghB3AAgbhA3iBvEDUHcAAAA4oYQxA0A4gZxA4gbgrhB3AAAAOKGEMQNAOIGcYO4QdwQxA0AACBuCEHcIG4AcYO4AcQN4oYgbgAAAHFDCOIGAHGDuEHcIG4I4mbZyDupJrd0X02U3KaUx983p1NObhVHP+FnyWVS6az1M+WcVNotMk4EgPogepsQ3fsZO+N9kfdSJoe4IQRxA3BfTI11XDn70NDFLYPtzsSu/pFDR8W3IrOTl070fffY4HfP9H9/ujRUdrQ8eGLi0p7bxdGRs5uXSdzcLf24/4X3Cr1bp8fPiwubmeheclOjV9yx/t380tcrR0+/s+/Ye8troy6NF5/rICSWjVdxk3NW19csQkIhbgCgrn1OaGEMI+O5bCdf5vgU4oYQxA0A4gZxA4gbgrgpR9HVFTHKcRiyQ90lDoccYSmN2uO34EQOyznhfWW3R7dfyqblTieTjo9S/DO6mdg9atVOOKrxzpVONwXH6DvYqjXvgGgjiYqb6LvUx8HdAMAySJygLyoniD3H7VBxQwjiBgBxg7gBxA1B3CxN3HiqRRuT0JWoY+Q4xHcl2okExiccpaj2fefij1t8HZMUN2YjoVIJJhSo9/rnCoSRtkviSN2yfDVynaa4sb8LawMA9cfrQmWHo51yyqwBlP0SU6UIQdwAIG4QN4C4IYibpYmbZG2/uScUK9rImDIlLm60A4puJ+5LRy8pNpvJfq6KjZQVN0yVAoDlJNZfBb2TX+WnhHjYOyFuCEHcACBuEDeAuCGImyWIG13AYjgOvSdQIdYWEuLGHJnYxY3yKaZzMVbzjNTvROZehYU5kePDtySmSsXfhbgBgGWxNhUWtRH9mCr6Q9wQgrgBQNwgbgBxQxA3tYkbXdW/6Iqb6uJmERU3wbYpiRITrxZsV2Vdh7jsU6XUZ0HcAEBdUTNJy70qOiVz8lRsrS7EDSGIGwDEDeIGcYO4IYgb221hv4A/sS6MuSqwGIeUWeOmuripZY0bvTyN96oWN36NTPxchv2xrHHjv8UyVarMuxA3ALAMM6TM8kDj8VI8DpwQxA0A4gZxA4gbgrhZBOphT242+VSpxDOkyjxVqrq40Sdy3HAMo6tgvDc6TlNk5U5jTlMuqI6JVNzoK9GjIH0TO74UTniu5LvkHtwNANSxR1UEXZblKXiIG0IQNwCIG8QNIG4I4qYxxzXJG872WU4AABsVxA0hiBsAxA3iBnGDuCGIm5XFXDk4cW8ZcQMAgLghBHEDgLhB3ADihiBuAAAAcUMI4gZxA4gbxA0gbghB3AAAAOKGEMQNAOIGcQOIG4K4AQAAxA3ihiBuEDeAuEHcAOIGcUMQNwAAgLghBHEDgLhB3ADihiBuEDcAAIgbxA0hiBsAxA3iBnGDuCGIGwAAQNwQgrhB3ADiBnEDiBuCuEHcAAAA4oYQxA0A4gZxA4gbgripO0U3nXJy99VEyW1KOfk6XU/eSTW5pei+XCaVzpaqX0c2nXwvAEC9EH1RSKLb9PrStFuMH5nsuxA3hCBuABbH5fE33PxCz/G3r5zeeerKzOFrXUcGnyqceKR04+pY367Bk85Iz9ahnufKvb00c23gwmMV2r9/caObmrsjLuzmWM99iJvsWN8r/NLXK9Nb5+5OLO8pZkYuSLNJiJnXF8+6Ezd1xSZuahVIiBsAWNbeKZPTXiaTi/nrVChujL4o5xg2B3FDCOIGAHGDuEHcIG4I4iYpZcybw2ZpjBxOiK/GAfHjpUZxnKbgznEw/Mg7qXLNLrGFuLhxM5FXg4ob3zE54X1sXeMTtJZ2MogbAFgpiWN0X6VsOp1xwoob0SXGZQ3ihhDEDQDiBnEDiBuCuLEU9Tuh3fBuDuvbv95gQwwzDNUihx+2430n4u/07yd7d5j1DWRvrOLNAlDixmtBzgtYZAux4ZDRiH9P2xA3ifb9nbp9xA0ALD+R+j7Zi+qpUl4362bTTJUiBHEDgLhB3ADihixjvv2NT4n/sRZf17C4MW8Im/OhvJKWdDo25Ch3vLHTG6hEtYs5R8BTJ+ZZ1BimphaqXLYhboyaHSWG1Ge5j2lWAACLKWaMLGcTdoBK3IQTqaJHIm4IQdwAIG4QN4gbxA2pW/7+L//z/pf/am1X3OjpSNFpSrG1hCOOJnG8oUJC7WLMhwpeChuMzB0I7UxNLcSnSpXKihtTP3mHRe57I24AYCWsTXSqZtzRmG7a6x5jRTeIG0IQNwCIG8QN4gZxQ+pTbvMvf/VXnv7eH4uvcnv/y3+1bfPn/uQz/0Fsi4jt3/zA/ypeamhxY7MY/uwk17EW11TUKFq7mJMFvD3VKm6qt1Cm4ibcriBuqLgBgJXD65QiFTTGc6aU8jblOOKGEMQNAOIGcQOIG7KcFTff/santm3+nNoptj/9B/++6/g3pbU5e/AfxMaaWOPG8yNq+WHlO/Rd4vgaN/r4pHYx7Emta9xUbyFeKKSX2omvcZMQN/qyWeMGAFZuhlSFV7WSTogexA0hiBsAxA3iBnGDuCH1FDdnD/6DLKtRFTdy1Rux8eU//4jYEDvXyFOlkgX8oQ2RyzHEnyqVWErGGIqUwkU341OlFso9VapqC+piok+Vir1qFzd6kpeTddOIGwBYHnTHZX0oXmLhm/jz7xA3hCBuABA3iBvEDeKGLN8aN9LUrD1xAwAADQbihhDEDQDiBnGDuEHckHpOlZK3TNdqxQ0AACBuCEHcIG4AcYO4AcQN2chB3AAAAOKGEMQNAOIGcQOIG4K4AQAAxA3ihiBuEDeAuEHcAOIGcUMQNwAAgLghBHEDgLhB3ADihiBuEDcAAIgbxA0hiBsAxA3iBnGDuCGIGwAAQNwQgrgBQNwgbgBxQxA3iBsAAEDcEIK4AUDcIG4AcUMQNwAAgLghBHGDuAHEDeIGEDeIG7JexE3RTaecnLmRd1JNbqnyu2o5pvLp7vOYupwIAOD+yGVSIUaH4/U/Pplc8sh0toS4IQRxA1CPf8C3JsTYY+TKdrHd1/nIxPBxsTFxeW+/e3n09Mnx/Ivl3nh7ujDW+cOVETcAjcD+wrYDI08TYmatiptFSZllFTfL9LkAAOqL6AlDNeN5mWA756RSTl5slNymQNOUsumwzxSvpt0i4oYQxA0A4gYAcUMQN5VdRmBevAFGcK+4csWNuoEsX/KPcTOx+8zeKCXYlde3mR3zdrRxDd44x29N37KWwx7jGG+049+idjJp/1XvFE7GScXuZucdfdc7Hz2p5VPLjXTa/DjmpwMAWILESfRyoa8RHVdc1iBuCEHcACBuABA3BHFTi7ipcaqUvkWcy/g3kH3ToW4pS4Gibzh7r8rjfc+SDwcw4tXwLEE7kdOFY5vIJcl2fBETihvDtqjjg8vTt7WTnysmbtRNb/12/VkAABaF7nzMLjSwOaIHc9xAQzNVihDEDQDiBgBxQxA3dRc31j3mLWVPdqjZAYavSc5X8ve4wVvKNB6+q2QcFm7rqQfWGQeVPldc3MRuid/fFDAA2MhY9XFE3JgVhUyVIgRxA4C4AUDcEMRNXcVNZBySEBymuDEJC3OS4ka85DrG/lLsRrRRlWMVN6EeitQBaWoUN+b1R2BlHABYbNdqzA+1V9woWWPaZ8QNIYgbAMQNAOKGIG7KiJtKU4pqrLixiJtE/UuZiptYNY0SOLE6nXIVN3FxY+qhihU31rkMtisBAKgNc95l2Z7W7LgQN4QgbgAQNwCIG4K4qX5b2FgpphZxY9T2B1UwNvGhC2T0ifT8qWAAo4c0gXYxvEmta9yUFzflPlfiU5ufMfbpmCoFAIufIWVQ5qlS8SXAEDeEIG4AEDcAiBuCuEmgHtLkZh3j2bT2p0rp9YMXEs9dsles6KdK6Teqx1GVnbiUeJflqVJqWRzrVCnVQtrNm2IoOKnlU8fklH4oFfOkAGCxPWpioqXq94xqPjWj03joHuKGEMQNAOIGAHFDEDfrZXyUnFwAALA+QNwQgrgBQNwAIG4I4mZtkjfWO2YZGgBA3CBuCEHcACBuABA3BHEDAACIG0IQNwCIGwDEDUHcIG4AAABxQwjiBgBxA4C4IYgbAABA3BCCuEHcAOIGcQOIG0IQNwAAgLghBHEDgLgBQNwQxA0AACBuEDcEcYO4AcQN4gYAcUMQNwAAgLghBHEDgLgBQNwQxA3iBgAAcYO4IQRxA4C4AUDckI0obnKZVAInF77oqH1NbmkVRi7iAtJu0Xqd6iJrbWHp5J06f3zRoH/93ofK5OK/jkyu6q8snS1zOUU3XetPBgCWl1I2bf45e99K1M687mKdPOKGEMQNQD24W5osnHjkRs8OsT2QezwQN8Mnrpx9aKj7h/fTMuIG1hkDFx4bvvTi5SNvT21aIESm4StuPEcTHTl4e5Qg8IYcq+BuouImNgTK5BbVQgOKG71R9rewSBA3AI1jbeKORvZFJbdJdq3i7z38a413BYgbQhA3AIgbAMQNQdxUEzcJU+MNNoIDPDsQLXvx1YabCXeGBwTeJ/ZqspxHKxi1UxzmnVE2I0Y78VKUQKb4Q6CmdHi/Wr0l9q0eLyVubptnrPTpSnGVk06rQiR121wfZvt0YctORg3Soj/2cPCm78wb3kp+TPEjDStu/N9IxjHOkvgsALAaeP1Vk5sz/HLENVtcsEXaIm4IQdwAIG4AEDcEcVNh2KDuCduPlC/JwYkyF4YriZaT+K/qt3ijF6N9T2dosSKvIRzklK24MdtR+6PXI98YbSH+qvWMtk+XFDeqkCd6/eU/XbTl0K2YnyswMsa9d/Wqvhg9Vco/XewTUXED0JBTpeLiJvZ3qjsKxA0hiBsAxA0A4oYsKVcfmvvt9z0gixnEhvg2eczII28+/6f7zT1tf3leVV2sRXFjn7NjqgE12Ii6BsNZJCYEWcxC6FYqvJRc4yawGKZgMq/ZnIwQdzT61eQZy306i7gJDouUJtlvpCc+nbmt32KZ1aUGexa/E/nsFX6GALD64sa0vaa6rSDKETeEIG4AEDcAiBuyCGvziX/7mdP/37DSMZ/94BdHHnkzdpg44J8+0RITN088uH29VdxE7hWHvsAQFnZxo3RGxOakIhOCLKs8lK24sQmmyEcIL0O1YHs1ecZqny4508GY1mRMU6r86SJ6JTiLIYD0lC4108pckDgyVSpfVX4BQAOIG8M+ezMcdZcSKRtE3BCCuAFA3AAgbshS8sSD25V/sRbUfOWBzMgjb372g18U2+aRa1ncWFYjFqMO74BqNSlVKm6CbfN0NVfcVBE3K1txY4qb+IVV+3SR88qLyUUmbSUaR9wArHVxY9sfWQMecUMI4gYAcQOAuCFLzFceyLT95XlzwpT4evYfRj/7wS/KOVPS7FgrbtbsVKkFy1OljPV0K6wCU0bcBI2H/kWfzm85XhQTyotFiZslrHFjPWNta9xEaohip7B+Ol3EFJsoEdbsJOde+YsNI24A1sdUKePvWq0IVs7aIG4IQdwAIG4AEDdk6RU3I4+8+ZUHMvv/quv9/+zfKC8j9qyvqVJ6Zyr5oKKKz10qM1XKcZoiz11SM4zMYpNEy3LSkO2pUjZxY3tulG7B/lSp5Gcp/+n0R4upHD0xypAv5T9dOus6yZ+n9dFayVNXFjfBe3E3AI07VcroIaPTLHmqFCGIGwDEDQDihtRljRuxIb41K27WxRo3y4llyV4AAKgE4oYQxA0A4gYAcUPu96lS5kwoOVXq/f/s33zlgczanCqFuAEAQNwQgrhB3ADiBnEDiBuyUbOhxQ0AACBuCEHcACBuABA3BHEDAACIG8QNQdwgbgBxg7gBQNwQxA0AACBuCEHcACBuABA3BHGDuAEAQNwgbghB3AAgbgAQNwRxAwAAiBtCEDeIG0DcIG4AcUMQN4gbAABA3BCCuAFA3AAgbgjiBgAAEDeEIG4QN4C4QdwAIG7IOhc3RTedcnL31UTJbUo5+WW8xlwmlc6WlqPlUjadyuSW73gAWH/E+gHRQUl0N5V3UiHJvhFxQwjiBmCJjI3/7GzuntgYObv57s0JsTE7dfnK2YduXDuEuAFQzL5y6PbVa32zF/eObbt+e/h+mhJ/GuIPhB/pOgBxs54GYIgbAKjeCQhUP5B3wu2cE2gasRF2qp7BiXewiBtCEDcAiBsAxA0gbkwpE9z0zcVLY8TQIu0Wc455QPx4f9TR5DhNwe1ktxi7mZxodokt1FZx4zsmV46azIuXo6b4qwvxW99Nbkm11uQdls58LWW2EDvSVFrep3BL6gDcDcCGxCuuaXJzZQSurTZQ2RzEDSGIGwDEDQDiBhA3iUGEGjDIwUZpQd8KLmXThmqResJ2vK8q/J2enfHHKtL4BHee/VGKEjdeC3LcssgWahc3RvuyEW+n2giUindLXMuX2NnNn4ZRQaPaMY4M76WLPYHBoeIGAMr0AxZHY3QsiBtCEDcAiBsAxA0gbmKYJfrx4pF0OjQX+iXr8cbOcKyitYsaxQTixjyLGq7U1ELt4kYbH2N6QtTgmDtlpUz0B+KJm3DQpdrRrmch8i5ZnqPsEuIGAJL9QDB/SvUhRt+YdNOIG0IQNwCIGwDEDSBuYtORotOUYmsJRxxN4nhDYUSLU8zJR2GDkdUcLOqkfAuLmCqVqHwxxU387BEdEx5gTmeIiJsINueFuAGA8v1ApMMxa/cQN4QgbgAQNwCIG0Dc2MWNTYv4s5Ncx1pckzzeql3io5dqFTfVW6iXuAnllO3sZsWNXdxYrkR8tLSbdZIVOgCAuClf56jnjSJuCEHcACBuABA3gLgpqzvUggt+OUm4/LBaesZY0zdX7vikdonak5rWuKneQr3ETXD2qmvcWKY+Gd5HXby6PLFH/2QQNwCIG5vMDadh2mdIIW4IQdwAIG4AEDeAuEmgn/EklURkcZnQX8hnM8WeKmU8/ilRL6NnFcWmSi2Ue6pU1RasT2NZylQpJ5N4WJX1qVLqXPLV2FOlLCVIxswvnioFgLgxOoFcJpV4IF104iVPlSIEcQOAuAFA3ADiBmKL0QAANCaIG0IQNwCIGwDEDSBu1izxBZJTiyhvQdwAAOKGEMQN4gYQN4gbQNwgbgBxAwAAiBtCEDcAiBsAxA0gbgAAAHGDuCGIG8QNAOIGAHEDiBsAAEDcEIK4AUDcACBuEDeIG8QNAADiBnFDCOIGAHEDgLgBxA0AACBuCEHcIG4AcYO4AcQN4gZxg7gBAADEDSGIGwDEDQDiBhA3AACAuEHcEMQN4gYQN4gbAMQNbBhxU3TTKSd3X02U3KaUk1/twZD6IHkn1eSWEleYzpaW7SdQ5ueSTcsr8TYyZc+QyySubdkuCQDq86dt/EWLP2GJ/kMWvVBIsm9E3BCCuAFY6r/hW5NXzj40P39X77k+WNy3ef7WTcQNQIy+2d69Y9uKd+6r20fcIG7WkbhpDCp9EMQNANTv71qg/qLzTridcwJNIzbCv1/P4MT/lhE3hCBuABA3AIgbQNyY4//gpm8uXhojhhZpt5hzzAPix8vqFcdpCm4nu8XYzeREs0tsoXYjIy87OGmArK+xVdwEd8L9CwjkSPxOeLWfgLlTNuu372bCw8JXEzfb007GFzfqjP7oLhj1GT8NX9y4jnFM5COrt8fLiABgpfG6lCY3V0bFWiSstjmIG0IQNwCIGwDEDSBuEoMINWCQg43Sgr4VXMqmDdUiHYHteN8a+Dt9UeKNVZQ68RrxRylK3HgtyHHLIluoeSpWKGW89mN3uRPixlckWsd4J/I29KnjxqfsT8w0LKX4J1InNc6lX41V3Bi339VH8O2SPEXis+gLVj89AGisqVIVHI3Z5yBuCEHcACBuABA3gLiJYpboxyo4mtJpVb5h+o7k8cbOcKyiRUZcrJhnUcOVmlqo4S536DgSoidxdkPuqIMtb1SFOVV/ArFSl6h8CZq1Hm8qpMQwT+00JFS4M2xN2yXrlQBAY4iboJKuttW1EDeEIG4AEDcAiBtA3MSmI0WnKcXWEo5oi8TxhizQY5XY1CHVYGQ1h9DO1NRCDZ/FO9IwPnpOUzjpKa5OIkMmZVjUMqL2OVaJn0BEnSQESlLcWFWLMcwzZnilLDbKIm4isPANQMNW3MS6i7JVcogbQhA3AIgbAMQNIG4qFWj4s5Ncp5bSkoUy2iU+eqlWcVO9hVqmfaXdvJs2VFEoOxZTcWOqJWvFTcWfQC3ipnLFjTmus1bcBNumuGF6FMAaETdGD6PnjSJuCEHcACBuABA3gLipIDuCyprIai9q6Zn4Ori245PaxbAzta5xU72F2mZLpSKyxlxs2CpuYuvORMWNXoCmyk/AWKIisCqVxY1uxLLGjSFu/EWR9Ro30fda1rgxl90BgEYRN+Z2KGErPsYOcUMI4gYAcQOAuAHEjUbPJ1Jr3+rFZULpIB+rFHumkvH4p0SFiJ6/E5sqtVDuqVJVW7AuXpO8lW2sjGM8qil4b4WnSqUc13BMwQfMR1RL2Z/AQuK5TlXEjT7eyRqaLKUWZg5/PpHKoOCpUhVaY54UQGNW3OgJmNoFR6c48lQpQhA3AIgbAMQNNI64+aSNVRM3AADQYCBuCEHcACBuABA3sJriJuluVrPiZs0RXx5Yr+ALAIC4QdwQxA3iBhA3iBsAxA3UQdyY7maVp0oBAADihhDEDeIGEDeIG0DcIG4QN1Z3s/pr3AAAAOKGEMQN4gYQN4gbQNwgbhA3Dbo4MQAAIG4IQdwgbgBxg7gBxA3iBnGDuAEAAMQNIYgbAMQNAOIGEDcAAIC4YUhPEDeIG0DcIG4AEDeAuAEAAMQNIYgbAMQNAOIGEDeIGwAAxA3ihhDEDQDiBgBxA4ibBEU3nXJy99VEyW1KOfk1MF7KZVLpbGkFfzIAsA4pZdOpTM7sWCS6e8k7qZBk34i4IQRxA7BE7pamCicemZ+7W99mETcAiBvEzQYQN+sUfjIAYLU2AiVu8k64nXMCTSM2wq7DMzjxbqQ+4qYFAAAAAAAAAAAajEDcoNAAAAAAAAAAABqNQNwUAQAAAAAAAACgwQjEzQQAAAAAAAAAADQYgbgZAwAAAAAAAACABiMQNwUAAAAAAAAAAGgwAnEzAAAAAAAAAAAADQaPAwcAAAAAAAAAaFAQNwAAAAAAAAAADUogbuYAAAAAAAAAAKDBQNwAAAAAAAAAADQoiBsAAAAAAAAAgAYFcQMAAAAAAAAA0KAgbgAAAAAAAAAAGhTETUOwPla65vcIAAAAAAAAUF8QNw1BS0vLwhoHcQMAAAAAAABQdxA3DQHiBgAAAAAAAACSIG4aAsQNAAAA/P/t3U2oNFmeF+BYiMzGccatKIhrYaTaxtZFbVx0jw0jKclMidLCMIvRjbMZigIpSWM5TLuwwWphapW57AI33TCODbZEguC8dosFI1KN3kXS0lAgYgujXDM+zzkRkZ83895T730ekpe8kREnIyPOu4gf/3MOAMCU4CYLghsAAABgSnCTBcENAAAAMHXD4ObTj36lKH7lo09Hm3/00deL4uvf/rTf54PvPt+vO3BKx+1P+P2zzvHTb9e/7KMf3eBEzwpuHtaLordc79qN27J9X62KxWZ3Xeay2yziY/d/FqvqcWh/eC+4AQAAgOd1q+Dmux+0gcLRlOS77+/3yDy4aX5IhsFNk9qU2+6vatVnN31wc719y1ELdWqzF4U1++8avldwAwAAAM/pJsFNn9oUxypumpij1YYd4agPvtfs+b16wwff/qjb7/3vNkFPMRuORK2FJChs7E4jCW4mn/Y79F+X/Nnu870Ppt8ynNUH7z9jcLMti6KskhxnsX6Yrbipyu6c+/1DqU45LZ6Jc5k2D6riiptJsiO4AQAAgGdzo+CmjjmaIOboUKmo4iZEKqFupU1JmmqXNhxpjpprNrQZFci0uc/3fhptjIKbmU+bbzn8afQt43bCxucbKtXGMU1YMwp0kuBmt152QUw/4qk+sN0S6nSSZsdpzm4U3NRtTr5XcAMAAAD3d8M5bi4JbuKJb5r3dWgS0pN4FNLccKcfdVU5/dQ5P/1pOg6rT2TCsXOf1icctxB+RRPcxCOhmvf14XE7zz3HzTCOKU5wRsFNXVyTBjFxqc7007lqmklwc9ZoKcENAAAA3NwLBTdhCFI/emq/w/nBTRivVKT1L7H9Fw3Hzn2azJqc/oqo6ic+x/35vGxwMxPHjIKb0Yiqbs9YWjszN0WO4AYAAAAykUHFzeCS4CY+ZBqp9OYrbpITHs9DPF9xEz5+v0jLcJ4puBkt/NQMcZqb42a24ubIDDUqbgAAACBjLxTcHJ7j5qzgJtpzVMVz8Rw34yDpqjlu5ot3LnDeqlKhWKYZMzVXcRPNaFPvU3+UbhnPaGOOGwAAAMjXswY3wwipEKBMV5U6r+ImWlWqP/wGq0o1P+P9aBmpuVWl+naiVaWeIbhJFoeK1oeario1XUMqbJnJX6bVNDurSgEAAEAebhjccL2L57i5oVO5zDnjpAQ3AAAAcA+Cmyy8ZHAzM4FOOkXOqjqnEcENAAAA3JzgJgsvG9zchOAGAAAAbk5wkwXBDQAAADAluMmC4AYAAACYEtxkQXADAAAATAlusrDdbr/owc3+J7iPAAAAcFtdcPO7AAAAAGSmC24eAQAAAMiM4AYAAAAgU4IbAAAAgEwJbnjtPv/8cxcBAACAPF0c3FSrYqKsHtaL/b+Pj7vNolhV9X79Fl5YVjdiWxbL9a7pRYvN7sVP55NPPvnyl7/83nvvvfvuu1/72tfevHmjvwAAAJCVqytuqrIoyska1oKb7GR5I3IIbr7//e//zeWv/d0/+p+/+t//39/+b//3t//Dj7/0pS+pvgEAACArNwpu2nRgW3YlOKsqzguGIp0ciixeneZGrDeL9g6sH7rNu35LueqztkFdF7OoP26qYx6H29r++bhbL4tys16M7ulDt6UIOVG9Z3Lrm4qbH3ZfHW2ctL9Y1vuU/7LsNzbtD+9v4Stf+cpv/Kef/Ob/eNy/fuMnj3/90//zW9/519/85jd1GQAAAPJx0+BmruKm3tI+bzcP9tMiHe6ruextRFInaOFetCFOfR9ngpsh4gl7NilMvWcbxzTpTNrO6FtCZ6g/bfafDpUKvSJtPxzYncm+tdsGf++8887XP/vjIbX5yz/62d//jz959913dRkAAADyce/gpqme6J+3M5nZ5HUJ2UrITaJIJXnfqYObrmom5G7h8Ll7Gg/I6r9xvuVRcLMtk/bn+kwf64RyoZt455133vuv/3tIbfav3/x3f/SNb3xDlwEAACAfzxHcJFbmvXlecaQS5SYngps+TOlHVEUTUbdDpfpb30UwUdYTl8kMo+S6/SfBTRIMRX0mdK39Ie3Iu5uOk9r78MMPf/uT3x9Sm7/2w//1jz74x/uNugwAAAD5eI7gxvColzQX3JyuuImDm3HWFlfE9O/nKm7S3tJsObviJuoz9TCr9a3HST02q4B/9atf/Qcf/tPf+rf/+R/+qx/8rb/z9/7FN//Ze3/+L3788cd6DQAAAJl4xjluomlQeD5zwc3pOW6SKpiofKYfKjXbzmiOm2hk3MVz3MRhX1O2c+NxUoOPP/74w8Ynn3zyV/7sn/svv/AXfvVP/inZDQAAAJm4cXDTrRB0YFUp46RewGxwE8ZANQtONfdlvgrmMVr1qWunCVZWZTIG6nF2VakqHJkOlWq//ciqUkmV1uh87ubNmzd/9U//GdkNAAAA+bg6uOHtkMwEfP4hzzn87TnntB6ym7/xJ37uxz/+sf4BAADAyxLcvEqhiOaKMqjnDG6iYVnP5c2bN+/8/C/+pZ//BcENAAAAL05wAwAAAJApwQ0AAABApgQ3AAAAAJkS3AAAAABkSnADAAAAkCnBDQAAAECmBDcAAAAAmbo2uNmWRW+x2R3ZsVqd2IHnU9+1sjpxTxfrh/Nae1gv2taGNwAAAMBNXRXc1E/4w+P9br08Fs0IbjJyNLjZbRaX3SnBDQAAANzZFcHNJKmJntv3D/9DIc76IfzZ7T/U6SzX/fFVt2lVlkMYVDfY6uOA/YHLRb1x+a1vLYty2x+8Cu85qL+e5apMLml0L8KNW1XT+9je9P5SV92d6u57fwdlNwAAAHBrlwc39eP6gdE0UUFHteoigFBxEw6sU4Dh0ygpaD+tg4D2kPrTNuKJanzqPVdVnyAIC05Kr2eokRnfi3BhZ+7jkeBGxQ0AAADcy3XBzemn9CEFGIKbestQaFNX0OzfV6HKZhoHxPlCPMZnv3FIc1bigkvuV/9+7l7Eidj0PgpuAAAA4AXctOKmLd8YTIObRFklTfVxQDIPS7QxjK7af0u90Tips4wyryG4Gd2LJLiZ3kfBDQAAALyAW8xx0w9Zius45ituxgUdl1TchOCmnUZ3bZzUWQ5V3Bwsrpm9j1FwM9wUwQ0AAADc2W1WlZo88DcT1h6c4yZMXnPBHDdRcNPNtmuc1FlC0DY3x024yHPBzXAf07ssuAEAAIBncVVw8xitSZQEKNECQ/HMKdNVpZLBUO2yU+tTq0pFwU0ycodT+uuZlClN7kU66/P4PqaNjGqj2v1lNwAAAHBj1wY3N5dMbXOKEg8AAADgFXjZ4CaeBPfQhMcTTamIchsAAADgrZdNxQ0AAAAAKcENAAAAQKYENwAAAACZEtwAAAAAZEpwAwAAAJApwQ0AAABApgQ3AAAAAJm6IripyqIot+Hv3WZRrKqnnsjDelGkRm3WO5RXfs22PuWqfbNc7844ov5RvfjHzl2Nxfrhi3bbh4v5lKsKAAAA3FlWwc3dEpALg5smtRnijPHvnVwNwQ0AAABwF7cNbnbrZVelstj08UgdmjS6xKTeZ7FcjCtZZoObZuOibrOs4ohhrs1yVY5LdfoqnuajKLiJ45v9PuMoZ5LUhP2rMikIGn5ve+bh54fD+1Otz2H4ovH5P1ar7pos/vm3FklmdItUJVQzta0Nv6K7quuuvCi6/mfeNQAAAOCebhncRAlOnziEOKYJNYawY1qhczC46b8rKRKZa7ONGOrEof20Ps82P6pWRVpxE8pk9uccMqaQWczGJU140e4cziE0VX9L+7vSc2jOPzrD8KPCpaiPjUOobX8mTy9lGl2HcA7DxZz99Ly7BgAAANzTnYKb6KO4zKR+H8UfsdEcN+MEIWQNp9rsk5S4Qmd439fOVKshOpmkRWcNpxrymvjNcFn68GVbTk51srE5sRD6RFlSf5JPM74O6cWJr3B/YhfcNQAAAOCebjzHTVPbEsYKxVP89kN1ooqScb4wW3EzDl9OtdknKXHhzCS46YpZZsZJHam4iQYQhYFFSXATW2x2cwlIGov0J1YPlRpike6sbjROKvk5k1RrNABtOMMz7xoAAABwT1cEN+Nn+Lha5DENCObmLb5FcHOszbMqbtrBXOvpOKnuo8n8O12SMvmWmTeRSypuojNp6oA25W2GJp2uuJkLbs68awAAAMA9XRHcxBOyJNPQROnDdI6b4ainBjen2hwClDC6ZzLHTX/sgQWhpqtKNe2E4KbZ4fAcN+GaXDDHTRwhtTUvNwpKTs5xMw5uLrhrAAAAwD1dE9w8RkOi0nwhDBeaLqvURyFPDm5OtBlVvvTz5iw263K6HPjRuWzi4UJDpDJsXGyq/hvblaTGq0pNFtVqKmiOryoV1/7cdpXu8apSw52arNU1PcPjdw0AAAC4pyuDm7fAOCu5/9edP/RpbrASAAAA8Oq8zuAmGrh0V/FSWWd/XRjYBQAAALxur7fiBgAAACBzghsAAACATAluAAAAADIluAEAAADIlOAGAAAAIFOCGwAAAIBMCW4AAAAAMnVdcFOVxaCswsbF+uHMw8/cE55gG/ppua037DaLIlH3w2qVbgtdurVbL/tPluvd0IlXoYVuv7jxVeXyAwAA8HRXBDd1arPY7KKH1fZBV3BDVvbdrI9g6gRnFMc0ycs4XqkzmqFvDz283xI+rbt9G+JELe8bHB0LAAAAT3R5cPOwXiSxS53jlNuhKqH9KCrJaZ+Nm6MW9T7v/5PluFQB7qztpaNuPI5y6hQmqqmZGvKaKKMZWq7/CyRfMf5fU667kpx9z+//g/TJUaj6UaoDAABA5IqKmy6jmTyjDnU0UdnCkPLUb4ZDVNzwvMZp42x1zNHkpT+qCVbiPYfePjt+MD6B7hubjGb4T9G8CYHRvjX/NQAAAAiunZx4MnvIgTim35g8OQtueE6TAVBXldtEo6Li+p2+8aiH19HMqKno07pspyur6f8jnPxqAAAAXqsnryoVnkijOCaKdaLigiumMYYnagrE0vFHUXQSnJihpu7SQ6edrbiZ/U8Rb+n6/0xwE01sbJYcAAAAYpcHN/sn2OShd3iIHZ5C43qEuOJGcMMzSybSnvTY0Z4H+2Q0A3e/98wcN5FpRc+p4ObouQEAAPB6XbmqVHi2DJUIM8FN88QruOFFzNXCHOp+s4OnQg8ffzSzqlQ03GlmvaqjwU20xRw3AAAAJK4bKhXPw5qMHymGB9Fu3EfVVRAkD8ZhT7iXZj7gWJc2njfBzVBTE9Z7asXpTLo42tDtZyasOVFxMyzKZqgUAAAAiSfPcQMAAADAfQhuAAAAADIluAEAAADIlOAGAAAAIFOCGwAAAIBMCW4AAAAAMiW4AQAAAMiU4AYAAAAgU4IbAAAAgExdHNxUq2Kx2XV/PKwXxejPxfrhyFG79bIot+OPEqvqKb9nOL3kPOFQfyvKpsNVZdgy34ebfdKP6g5fVsmfjeVazwMAAOAmLg5udptFyFa2ZbFcLIbH1PrP+UfWE8FNCGvqHZ6S3chrOL8v7ztb11tGEcxczypHmU4X0wxH1Tu0fTvt0gAAAHC9y4dKRY+4+wfUchvKEHabRfcYvA3lC8Oj7HnBTVS2Ez9L95FQ3c6yfl4eWiuiGoc6VGpLJja7KMEJu3Vf3bRcrtKNvDZxzng4c+w7TNLVmx6+WG+jLhqVm9X9cNRa0+XWXf/c79YX+PQ9P9QBSXwAAACIXDHHzW69bB9QuzdNfPMYQpm5J9gLgpuknZngZngkjg5Mih1GQ6XCIe3D9kMywitukNck6YpD5FcURyq2jg+VCvU7MxU3oy4X+mHzJsRGw38uAAAAqF0zOXGXiewfO4dApH5M3T/WTgabxJUytwpuZkoSQrOT4Cb+xv7ROp6L53ipBW+r9L6HftUV18x3/BNz3PS1XTPRzyjNDIHjKLgBAACAxFWrSrVJzbYM84PsHzuHHGc0/+vFwU1fPnNoqFQ6NfKBMVnDm1CM8xhHTpOWeVWOzIV0eIaao8HNGUOl2j1ngpt0lJ+7AwAAwOC65cCrcrler+JKlrIacpx6RNKhwOXKOW4mQ64ek5llr6m4Edy8ZpMIJu2QB9KTY8FNEtZMl1c7Fdz0Zv6DAAAA8JpdF9zUM3EslmGQSLValKsymre1/agZOXJZcBOtKhUGrUzbeUyCm2Yu5AvnuBHcvGJzQ5yiiauvWg58VHEzGjZ4NLiJtpjjBgAAgMR1wc1kMEhcZRNWcQrL7pwIbmJR9c1uWIVnMzdUali7alUN29tDzllVSnDzes3c9KosxquMTUpvTs1xExZTm4QvJypuQhc1VAoAAIDYlcENAAAAAPcmuAEAAADIlOAGAAAAIFOCGwAAAIBMCW4AAAAAMiW4AQAAAMiU4AYAAAAgU4IbAAAAgEwJbgAAAAAydV1wU5XFoKyO7Lgti+V6176pLdYP7Qe79bIY2+857A/P6WG9aDvhqprvxvGnw869xWaX7KYPAwAAcCNXBDd1atM9qT4+7jaLY9lNH8TsdxsOmTwwD2kOvIi6S5fbxzZPHHfU0EXnPq3Dmqb/N2lO08hjtToQAAEAAMCFLg9uxlHL8NAbVyL0UU4T3PxwsygOlTOMWuuCnvoJudx0re0flesn4aS6JxTsdF8NV6s7Yde16iByVC8zRDMziUzTUbdx1x03GH/FuvuPsO/wfc1a31rfwyU+AAAAJK6ouOlCk0liEhKc+il0GCHVV9zMP5EeDm7iMVZNmUOodwjPz/WnCnZ4mjhziWKaSceeVNyMDkyCm7RbNplm6L3tp8Nu4dj9V+jPAAAABNdOTrwNs9yEioPhiXeoOHhCcNM9IUfFC/sn3mZjVOMTlzzAVZIqm5ng5nGY1CntaWnfi4ZKNeMHp8FNtyX6v7BvdhTcAAAAQOLJq0rFVQPphK3xE+kVwU00/GomuJmZGhauc7zi5tBQqcl4qF0/JHCxKmeHSoXRWKPgJj5WZwYAACByeXCzf46dneZjtmrgXsGN4STcztE5bpKwJgpxDnbpx7n/C6eCm/H/JgAAAGhcuapUeLYMs8yE7WGpqbsEN9GzdDQ+Ba51dFWpUcVNn8gMvTHqye1uh5amOhjcRFvMcQMAAEDiuqFS8WCl6DkzrCrVb7xPcBOvKmVoCTcwdN1omad0zfuZdc1GieHuxOppRypu9GcAAADmPXmOGwAAAADuQ3ADAAAAkCnBDQAAAECmBDcAAAAAmRLcAAAAAGRKcAMAAACQKcENAAAAQKYENwAAAACZEtwAAAAAZOry4GZbFsVi/eDSAQAAANzXpcHNbr1clKvFYrNz7QAAAADuahTcfP7ZD/7gD/5N+vrBZ58Puz+sF8v1bv9vUVbdpt16WSyWi6Ioyu3+z6osGquy7AtzqlXRWVWuOAAAAMCZxhU3n/3eLxepX/69z4ZPd5uu1qZatTHNYxvcDIlMndE07/d7diOqtmWxXO+6PY2xAgAAADjXZKjUz6ryl6LY5pfK6mfDZ1Hysi37sKapuOlGTlVlmP6mfx+CGwAAAAAuMDPHTVMs00nmsqlHSMXa0VJ1cNNV39Q7TIKbqEEz4wAAAACcb25y4qHoJim3CcOghj+bICYKbmYrboJ4TwAAAABOmF9V6vPv/HpRFL/+nc+jbfWsw3HsUtfR1GOgkjhmOsdN/SYMqjLHDQAAAMC5Di0H/oe/s/ydP4w3bMsirCTVaEZOldtRHU23qtRis+4rbprZiw2VAgAAALjQoeDm8fGPn9bwNOgBAAAA4BKHg5trhOKaojAqCgAAAOBJbhvcAAAAAHAzghsAAACATAluAAAAADIluAEAAADIlOAGAAAAIFOCGwAAAIBMCW4AAAAAMiW4AQAAAMiU4AYAAAAgU7kHN7vNoliud7OfPawXRVnd6UtXTcPb8uC381ba3/H7dCoAAAC4guDmwJe+RcFNdw3ry7VYP5xzRFW+2vDijOCmvp6Ncnv0Iq5O7BBd7XrP/f5drwMAAIDe/YObJl5Zd8+6i/VD/ZhaG55R6x26B+EqeX6u9y9XbXCzWy+Hx+B9C00AEQc33f7FsZxlfCbj5/Bu49DU/gyb4Ga9mpzeF0qXQwlubupkLnNJcFPfF8ENAAAAU88T3BSLza59lC1C5tKGCHWOEz5tY5fmkOaht85rTgc3obVm/0NPv21C1HwaCnmiCovhyTmpuInP5Iv5XN3/nCSOqVZ9WLUZkq7mN45CtEkitm+t3PRZ23BBht3ibChs7G/Tsizrr+jiswO5Rn2eZdtVNmU4w2nAt29/te7POfy0kMQN3Sk6+ba15s26TH7abtpU9KXxhTo7uOkvVDg2XJPhWnX9eTg3AAAAeObgpnuYD4HIbNXMsGc8QKl7fyy4SYZTHRnclJSc9I3MBByj4KY7vejkv/CijCBc2Go15At9xJNGHuHidNdkuIb7Ria1PNOBbF0e10Vgh3OKLsvrgrw6nUlTp+EW13cndK2utWkHOBDcxIFdFMEcqjYa/8ZzgpuQWI2vWHy1AQAA4KBnGio1yT76J9hkSpFQenBxcJM4MMwniRLi0CE6dBrcTJKLL770J3eVL3Fg0b0fX9j+4kShT4ghRhU0M7lMF6B0Rx0Nbupv75KRNrhJClWKENxM7shMnnKw4ubYt0d/FjPFRJcNlRraFNwAAABwmZcObq6ouBl2i4ObcyKVuOKmfx+HRPMVN29ncDOd7GY+uJmGC7PBzRBVDPHN7YOb6cW/f3ATzTtzTcXNJLiJIjOrlQEAAHCGlw5uZue46dfZGc1xEw3VOTTHTdzI7JkUYaRMs1sU3DS1Fa8iuJn9LcmYqckYn+TYQ8HN42jI0nSo1IHgJnxjFHMkwc3c0LbZ4GZmGbKknxSXBjfRzzkR3KS/Yi64iSIkAAAAOMeLBzfHV5VqpneNZixu5nldH1tV6shySM3+5XiJqGEsTFklk6eEVaXevuDm+DzE5TaEF/FoqUkpzRDcxOOJ5iYJTmKL64KbZFrfEKbM3ZFh3uXh3vVb6kmRDwc3VTkdjTV0znoW5GRc2HT81OngZjRITYgDAADAywc3+ZirH4HnkyRNczVEAAAAkHorg5vx5LtdZcS/F9zwspKinuNT5AAAAMDj66q4AQAAAPhCEdwAAAAAZEpwAwAAAJApwQ0AAABApgQ3AAAAAJkS3AAAAABkSnADAAAAkKn7BzcP60VRVvs327JYrncuOQAAAMB5njG44YXsNos6MqtvxGL9EG3cW1XpneosNrt0Y3wHq3L/9/axWqWHAwAAALf2/BU3u/WyKFdllxAMT/4hNZDy3Fid0eyvcxTcVKs6mum293vV92Xbvq/K+JaNo7f9p3U7ghsAAAC4t5cJbroxU/stXZTQFXG0mYIRVbfVBzR9HDPe3glBzGhQ24HgZn94KMwBAAAA7uBlgpv+gb+LAJoEp48GDK16LqPg5nF2/JQ7AgAAAC/nhYZKhSE5Q3ATC1OxcD+j4KabCmda9CS4AQAAgBeSTXBjeNSzS4Ob/l40n0T3SHADAAAALyaP4Caa46YZrSMmeA5HJyeOip4ENwAAAPBCMglu4lWljJO6u24um153O6LlwKdbZua+AQAAAO7s/sENAAAAAFcR3AAAAABkSnADAAAAkCnBDQAAAECmBDcAAAAAmRLcAAAAAGRKcAMAAACQKcENAAAAQKYENwAAAACZEtwAAAAAZEpwAwAAAJApwQ0AAABApgQ3AAAAAJkS3AAAAABkSnADAAAAkCnBDQAAAECmBDcAAAAAmRLcAAAAAGRKcAMAAACQKcENAAAAQKYENwAAAACZEtwAAAAAZEpwAwAAAJApwQ0AAABApgQ3AAAAAJkS3AAAAABkSnADAAAAkCnBDQAAAECmBDcAAAAAmRLcAAAAAGRKcAMAAACQKcENAAAAQKYENwAAAACZEtwAAAAAZEpwAwAAAJApwQ0AAABApgQ3AAAAAJkS3AAAAABkSnADAAAAkCnBDQAAAECmBDcAAAAAmeqCGy8vLy8vLy8vLy8vLy8vLy+vDF//H2Ee1LgwBv8+AAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Chrome `about:tracing`:\n",
    "\n",
    "![catapult1.png](attachment:catapult1.png)"
   ]
  },
  {
   "attachments": {
    "devtools1.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Chrome DevTools -> Performance.\n",
    "\n",
    "![devtools1.png](attachment:devtools1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exporting Tracing Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Single command. Use `EDENSCM_TRACE_OUTPUT`:\n",
    "\n",
    "```bash\n",
    "export CHGDISABLE=1\n",
    "EDENSCM_TRACE_OUTPUT=a.txt     ./hg ...\n",
    "EDENSCM_TRACE_OUTPUT=a.json    ./hg ...\n",
    "EDENSCM_TRACE_OUTPUT=a.json.gz EDENSCM_TRACE_PY='import sapling.*' EDENSCM_TRACE_LEVEL=debug ./hg ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Traces are also logged in blackbox. Use `hg dump-trace` to merge and export them:\n",
    "\n",
    "```bash\n",
    "hg dump-trace -o a.json.gz -t 'since 15 minutes ago'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing for Better Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Examples:\n",
    "\n",
    "- Expect a template rendering function to be called N times, under another function. How can I test it?\n",
    "- Expect a network fetch function to *not* fetch `foo/bar`. How can I test it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Today, in `.t` tests:\n",
    "\n",
    "```\n",
    "  $ hg show X --debug\n",
    "  ...\n",
    "  12 files fetched over 1 fetches - (12 misses, 0.00% hit ratio) over 0.00s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python tests:\n",
    "\n",
    "```python\n",
    "t = tracing.tracingdata()\n",
    "with t:\n",
    "    sh % \"hg amend\"  # code to test\n",
    "\n",
    "assert t.treespans() ... # check spans\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Rust:\n",
    "\n",
    "```rust\n",
    "let data = Arc::new(Mutex::new(TracingData::new()));\n",
    "let collector = TracingCollector::new(data.clone(), Level::DEBUG);\n",
    "\n",
    "tracing::subscriber::with_default(collector, || {\n",
    "    ... // code to test\n",
    "});\n",
    "\n",
    "data.lock().tree_spans();  // check spans\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Goodies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Date Parsing\n",
    "\n",
    "`lib/hgtime`:\n",
    "\n",
    "- Compatible with formats specified by `hg help dates`.\n",
    "- Support `... ago` human-readable formats.\n",
    "\n",
    "Examples:\n",
    "\n",
    "```rust\n",
    "let time1 = hgtime::HgTime::parse(\"Oct 1\");\n",
    "let time2 = hgtime::HgTime::parse(\"5 minutes ago\");\n",
    "let time_range1 = hgtime::HgTime::parse(\"since 10m ago\");\n",
    "let time_range2 = hgtime::HgTime::parse(\"Oct 1 to Oct 2\");\n",
    "let time_range3 = hgtime::HgTime::parse(\"Apr 2019\");  // Apr 1, 2019 to Apr 30, 2019\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Mincode: Fast, Compat Serde Serialization\n",
    "\n",
    "`lib/mincode`\n",
    "\n",
    "- Similar to bincode. But uses VLQ for integers to save spaces.\n",
    "- Compact and fast. Suitable for stable structures. See D17087352 for benchmark.\n",
    "- If you consider `serde_cbor::ser::to_*_packed` to reduce size, most likely `mincode` is a better choice.\n",
    "- @wez has also reinvented the same thing as `varbincode`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Convert serde values to Python objects\n",
    "\n",
    "`lib/cpython-ext`\n",
    "\n",
    "Anything that implements `serde::Serialize` can be converted to Python objects trivially and efficiently.\n",
    "\n",
    "```rust\n",
    "let mut map = HashMap::<u32, u32>::new();  // Invalid JSON \n",
    "map.insert(1, 2);\n",
    "\n",
    "let obj = cpython_ext::ser::to_object(py, &map)?;\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Rust Subcommands\n",
    "\n",
    "`lib/hgcommands`\n",
    "\n",
    "Register using `-` in command names:\n",
    "\n",
    "```rust\n",
    "table.register(foo_bar, \"foo-bar\", \"...\");\n",
    "```\n",
    "\n",
    "Supported syntax:\n",
    "\n",
    "- `hg foo-bar`\n",
    "- `hg foo --bar`\n",
    "- `hg foo bar` (if `hg foo` is not a command)\n",
    "\n",
    "Also works for aliases. \n",
    "\n",
    "Potential goal: move hacky flags away from main commands. For example, `diff --since-last-arc-diff`, and `amend --fixup`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tracing non-hg programs\n",
    "\n",
    "`hg debugpython --trace 'sapling.*' python-script.py` can be used to do ad-hoc analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Future Plans\n",
    "\n",
    "- Rage: Upload traces. Links to visualizers.\n",
    "- Scuba: Upload both ASCII and Chrome traces.  Links to visualizers.\n",
    "- Telemetry: Calculate derived data from blackbox in background."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## You can help!\n",
    "\n",
    "- Set up Rust tracing.\n",
    "- Add missing perftrace spans.\n",
    "- Write test assertions using tracing spans.\n",
    "- Look at the profiling result and fix low-hanging fruits.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><h3>Demo / QA</h3></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "bento_stylesheets": {
   "bento/extensions/flow/main.css": true,
   "bento/extensions/kernel_selector/main.css": true,
   "bento/extensions/kernel_ui/main.css": true,
   "bento/extensions/new_kernel/main.css": true,
   "bento/extensions/system_usage/main.css": true,
   "bento/extensions/theme/main.css": true
  },
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "bash",
   "language": "python",
   "name": "bento_kernel_bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
